TRACES[DIS,DBL] - www.SailDart.org

perm filename TRACES[DIS,DBL] blob sn#229970 filedate 1976-08-11 generic text, type C, neo UTF8

COMMENT ⊗ VALID 00007 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 .ASEC(Traces of AM in Action)
C00004 00003 .ASSEC(Prose Traces)
C00041 00004 .ASSEC(A `Nice' Task-by-task Trace)
C00074 00005 :: Restrict the Domain/range facet of Bag-union: because Bags-of-T's
C00109 00006 :: Fill in specializations of TIMES: because TIMES is very
C00143 00007 .ASSEC(An `Unadulterated' Trace)
C00200 ENDMK
C⊗;
.ASEC(Traces of AM in Action)

.ONCE TURN ON "{}"

There are three types of traces which are represented in this
appendix. First comes a high-level prose desription, a
commentary on AM as it goes through a long, successful run. This is
an expanded version of the historian's description of AM as a
mathematician, found in Section {[2]OVERV}.{[2]AMAMSSEC}, on page
{[2]AMAM}.

.ONCE TURN ON "{}"

Next comes a detailed description of what AM did, on a numbered
task-by-task basis. This is an expanded version of the task-by-task
trace given in Section {[3]RESULT}.{[3]SHORTASK}, on page
{[3]SHORTASKP}. For each task, a paragraph is provided explaining
what AM did, why, and what happened. These task
summaries start on page {[3]TRAT}. The task numbers listed there
correspond to the numbering in Section {[3]RESULT}.{[3]SHORTASK}.

Finally, several pages of traces are presented in totally undoctored
form, so the reader can see that (i) it ⊗4is⊗* harder to follow than
the slightly rephrased ones, and yet (ii) those earlier, "doctored"
traces didn't enhance (or alter the the spirit of) what AM printed
out.

.TRACES: ASECNUM ;

.ASSEC(Prose Traces)

.PROS: SSECNUM;

.PROSP: PAGE;

.ONCE TURN ON "{}";

In this section are sketched many of the paths which AM explored
during its runs.
Besides describing what AM did, this section will
explain why, and indicate where each path led.
Along the way, some concepts were created which were interesting to
⊗4us⊗* (in the smug wisdom of millenia of hindsight) but which AM
never bothered to develop. These will be noted, and a stab will be
made to apologize for AM$$ The typical excuse is that AM was
distracted at that moment by some even more interesting task. $. A
few exciting moments occurred when AM became interested in a concept
which had been ignored by humans -- at least, unknown to the author.
Very often the "new discovery" was never shown to be anything other
than cute (e.g., the concept of Timberline; see page {[3]GEOEX} for a
definition and diagram of it).

.COMMENT STRUCTURES;

AM began by exploring structures and structural
operations. After it was started, with the base of knowledge
outlined in the previous chapter, the main activity AM did for the
first several minutes was to fill in examples of various kinds of
structures (e.g., Sets), structural operations (e.g., Insert), and
create new concepts of this type (e.g., Singleton). In more detail,
here is what was done:

Trying to fill in examples of set-operations, AM kept failing because
there were no known examples of Sets to "run" those operations on. So
it turned to filling in examples of Sets. Some of these came from the
recursive definition of a set: "S is a set if S={} or if both (i) we
can pull an element y out of S using Some-member, and (ii)
Set-delete(y,S) is a set". A heuristic rule knew to extract the base case
from such a definition, yielding {} as one example of a set. Another
heuristic said to run operations whose range is `Sets'. One of these is
Set-insert. So a procedure for getting a new set is to take the given
set S, and anything y, and run Set-insert(y,S). When this was done,
using S={}, a bunch of singletons were created. AM literally collected
Examples(Anything) and randomly chose members y from that big and varied
assortment.
Other set-operations were run just to provide some additional examples
of Sets. Not every attempt was successful, of course: one heuristic
said to find some examples of Lists, and then use the View facet of
Sets to transform them into sets. Unfortunately, there were no examples
of any other kinds of structures at the moment, so this rule failed.
After about 20 cpu seconds, the time and space quanta were both just
about exhausted. Roughly 30 examples of sets were found.

In similar ways, examples were found for Bags, Lists, Osets, and Ordered-pairs.
Examples of structural operations were found "incidentally" as above -- to aid
in producing examples of a certain kind of structure. Occasionally, the primary
task (the one selected from the agenda) was to find examples of a given
operation. In that case, AM spent a great deal of time just on that one operation.
For example, consider Set-union. When AM got around to filling in some examples for
it, many examples already existed under the concepts of Sets, Bags, and
Bag-union. One way to get examples of Set-union was by analogy to Bag-union.
This caused some slightly erroneous entries to be found
(e.g., {a,b,c}∪{a,c,e}={a,a,b,c,c,e}). Such errors were soon caught and corrected
when the task ⊗6"Check examples of Set-union"⊗* was chosen from the agenda.
Similar errors and corrections occurred when AM viewed lists as if they were osets,
in order to find examples of osets.

The simple development described above was broken frequently by some new
concept being created and found to be very interesting. In fact, if left to its own
judgment, AM
would never finish the above process, because of these interruptions. The user
must interrupt and tell it to ignore new concepts, if he really wants AM to
finish finding examples of all those structures and operations.

What kinds of
concepts were created, and why? What did AM do to investigate them?
In general, what happened was this: As AM collected examples of a concept C,
the characteristics of its efforts (how easy/hard to find examples, how
varied they were, etc.) caused certain heuristic rules to trigger. Those
rules then caused some new concepts to be created, for a particular reason.
AM would find examples of them, then compare the results with already-known
concepts.

The first instance of this process was when AM found many examples of sets
so easily. A rule said that in such cases, it was worthwhile specializing
the concept Sets. That is, make a new concept which would have fewer
examples. One way AM did this was to look over the Interest features of all
generalizations of Sets, pluck a couple of them, and conjoin them onto the
definition of Sets, thereby getting a definition for a brand new concept,
called interesting-sets or INT-Sets for short.
The feature selected first was the following: each pair of elements of the
structure satisfy the same rare predicate P, for some P. This was previously
tacked onto the Interest facet of Structures.
Initially, there were very few predicates known: Constantly-True, Constantly-False,
Object-Equality.
The following three types of INT-Sets were therefore eventually found:

.BN

(i) Sets -- the same concept but in a new disguise
(for any pair of members from ⊗4any⊗* set, Constantly-True would return True),

(ii) Empty-sets -- an already known concept, but now with a new definition
(for any pair of members from ⊗4any⊗* set, Constantly-False would never return True),
and

(iii) Singletons `{a}' (sets for which all pairs are Equal to each other).

This immediately catapulted the empty set to stardom.
Another heuristic rule had AM restrict its attention to the predicates which were
not trivial. In this case, both Constant-True and Constant-False were no longer eligible.
So the only remaining INT-Sets were those for which all pairs of elements were
Equal. AM decided to explicitly define a new kind of set having just that definition.
This became a specialization of INT-Sets, called Equality-sets or Esets for short.
Since the empty set was already distinguished, it was decided not to include
it as a valid Eset. So Esets were precisely the sets we would call Singletons.

Unfortunately, the set-operation Union, when applied to Singletons, didn't
always yield singletons. By isolating the kind of sets they ⊗4did⊗* yield,
and not counting the few extreme cases when they yielded singletons, AM
discovered the concept of Doubleton: a set with precisely two members.
Typically, the union of Singletons was a doubleton, their intersection
was the empty set, their Set-difference was a singleton, inserting anything
into a singleton was a doubleton, removing something left a singleton, etc.
The exceptions were all related to when the arguments were equal.

Several more structural concepts were created and explored in this way,
besides Singleton:
Doubleton, Tripleton, Function (an operation, all of whose values were
singleton sets: i.e., a single-valued operation),...
In general, these occurred because the intial primitive concepts were
too general, too easy to satisfy.

During its investigation of Set-Intersection, AM noticed that sometimes
X∩Y=X, and formalized that relationship between two sets. This is just the
relation we normally call Superset. The notion of Subset also was discovered,
but AM never had much interest in either of these notions.

When AM looked for examples satisfying the predicate Object-Equality,
abbreviated Equal, the situation was just the opposite. A heuristic rule
attached to `Active' indicated that examples could be found by randomly
instantiating the two arguments of Equal with a pair of objects. There
were about 100 known examples of structures. AM gathered them into one set, and
then repeatedly chose a pair of them to run Equal on.
Thus only about 1% of the time did it succeed (did Equal return the value T).
Another heuristic triggerred, and said that in such cases, it was worthwhile
trying to generalize the predicate Equal. A new task to this effect was added to the
agenda.

Soon, AM selected this task, and tried to create new concepts which were
generalizations of Equal. One definition of Equal was a transparent recursive one,
which essentially said that x and y were Equal iff their Cars and their Cdrs were,
plus it had a base step that asked if both arguments were empty
(in which case Equal returned True), or if precisely one argument was empty
(in which case Equal returned False), or if both arguments were identical
atoms (True), or if they were nonidentical atoms or only one was an atom (False).

.B0 INDENT 0; SELECT 3; TURN ON "\"; TABS 60;

⊗1λ⊗* (x,y)
IF x and y are identical atoms, THEN return True;\⊗8⊃⊗3
ELSE IF either x or y is not a list, THEN return False;\⊗8εαα⊗4Base⊗3
ELSE IF both x and y are Null lists, THEN return True;\⊗8εαα⊗4Cases⊗3
ELSE IF only one of x or y is Null, THEN return False;\⊗8$⊗3
ELSE both of these must be true:
Equal( CAR(x), CAR(y) )
Equal( CDR(x), CDR(y) )
.E

One heuristic rule that AM possessed suggested that this could be generalized
in a small way by weakening the base step. A couple new concepts were created
this way, but they all turned out to be trivial: either constantly returning
T, or no different than Equal was.

Another heuristic suggested weakening the recursive step. One way to do this,
since the recursive step is a conjunction, is to remove one of the conjuncts.
The rule checks to ensure that the definition is still recursive: one of the remaining
conjuncts must call on the function itself.
In this case, both conjuncts call on Equal, so AM can remove either one. Two new
concepts were generated in this manner. For example, here is one of them, which
AM named "⊗8Equ0⊗*":

.B0 INDENT 0; SELECT 3; TURN ON "\"; TABS 63; COMMENT NOT 67 ANYMOORE;

Note that the base cases were unchanged; the recursive step is a recursion in
the CDR direction, but no longer in the CAR direction. A note to that effect
is placed inside the definition of Equ0 itself, as a comment.
Other parts of Equ0 can be filled in easily: it is a generalization of Equal,
it is an example of a Predicate, its domain/range is the same as Equal,
its worth is initially set a little higher than Equal's, etc.

This predicate maps down two lists, one element at a time, and returns True
iff they both become empty at the same moment. That is, iff they have the
same length. In fact, we can assume that the user interrupts and orders AM
to rename Equ0 as "Same-length".

The other new generalization, called "Equ1", examines the CAR's (i.e., the first elements)
of a pair of lists, and returns True if they were identical atoms; if they
were both lists, it recurses on those two lists.
A human LISP programmer's interpretation is as follows: when the two lists
were written out in standard notation (using parentheses), all the initial
left parentheses match, and the first non-left-parenthesis entity of each list
also matches.
Although this is isomorphic to numbers again$$ Two list structures were treated
as equivalent if they have the same number of left parentheses; zero is the
list NIL; adding 1 is consing with NIL; subtracting 1 is CAR. $, AM didn't
pursue this concept very far. Most of the examples of lists AM knew about
were only 1-level deep, although they varied significantly in length.
If it had been otherwise, AM might have developed Equ1 into Same-length,
and lost interest in Equ0.
As it was, the Worth of this concept Equ1
slowly declined, and very few
tasks involving it bubbled up to the top of the agenda.

The concept of Same-length will form the springboard for the development of cardinality,
a tale which is related in a little while.
Before moving on, let's mention a couple more set-theoretic activities that AM
did.

Several moderately interesting compositions and coalescings were done to set-operations.
(Actually, to structure-operations). First let's discuss the coalescings of
operations f(x,y) into new operations f(x,x) -- where a pair of arguments is
made to coincide.
Coalescing Insert (insert S into itself)
led to an operation which always seemed to give
a bigger set than it started with. This led AM to the finitely-true
conjecture that a set is never a member of itself.
The conjecture was rediscovered when the coalescing of Delete seemed to produce
the identity operation (Deleting S from S never seemed to change the value of S).

Coalescing Intersect also gave the identity operation; this showed that S∩S=S
(apparently). Similarly for Union.
Coalescing "Compose" gave a new operation of some value: the notion of composing
f with f. When this was applied to, e.g., Intersect, it created the new
operation Intersect-o-Intersect, which took 3 arguments and formed their
common intersection. By forming this in two ways
-- (x∩y)∩z and also x∩(y∩z) -- AM noticed that they were the same, that
the order didn't matter. Since x∩x had already been shown to be the identity
operation, multiple occurrences of an element in an intersection don't make any
difference.
Finally, AM had constructed x∩y and y∩x as two separate operations, and then
found them to be equivalent. Taking all these results together, it was possible to
view ∩ as taking a ⊗4set⊗* of sets as its
argument, and forming the intersection of all those sets. Thus
∩({ {a,b,c},{c,g,h},{a,c,e} })={c}.

Some valuable compositons were formed. By forming x∩(y∪z) and
(x∩y)∪(x∩z) as two separate compositions, AM found their equivalence
via experimental data. This was one case where the Intuition functions
had given AM an unfair advantage, since the Venn-diagram abstract representation
for sets suggested this relationship explicitly. When the intuition was removed,
the discovery was made much more valid. All of de Morgan's laws were discovered
in this manner, incidentally. Several special cases were singled out, involving
empty sets, singletons, and doubletons.$$
E.g., if x is a singleton, then x∩(y∪z) is equal to either x∩y or to x∩z;
if both those sets were the same, then of course x∩(y∪z) is equal to their
common value; if the two sets differ, then one is empty and the other is
x, and the ultimate intersection is equal to x. Or: that intersection is
always either x or the empty set. $

The compositon Delete-o-Insert is not quite so trivial as one might think:
it takes a structre S, inserts an element e, and then removes element e.
This simple operation can be used to test the type of structure that S is:
it ⊗4never⊗* alters a Bag or a List, but it does alter Sets and Osets.
Orthogonally, Insert-o-Delete always alters Lists and Osets, but can leave
Bags and Sets unchanged. The first composition tests for multiple elements, and the
second composition tests for order. AM defined both of these, and (at least
partially) perceived their abilities to distinguish structural types.

Operations formed by switching the two arguments of an old operation
were marginally interesting. They helped pin down the true nature of what
kind of argument the operation should be considered as taking.
For example, Union(x,y)=Union(y,x), so Union can take an unordered collection
of sets as its argument, and form their union.
Similarly, we see that Insert(x,y) is in general quite different from Insert(y,x).
When AM tries to see what invariants exist for this operation, it can notice only
that
the trivial constraint x=y is sufficient to cause the order of arguments not to
matter. If it had the concept of the LISP function "COUNT", which counts up all the
storage space used, or "FLATTEN", which removes all parentheses from a list structure,
then AM would notice that the COUNT's of both forms of Inserting were equal in number,
and that their FLATTEN's were equal sets of elements.

Looking for invariants is one favorite pastime of AM. In general, two operations
f and g will not coincide. AM wants to find a unifying operation U, such that
U(f(x))=U(g(x)); or, AM tries to find a U such that
f(U(x))=g(U(x)). This is of course the idea mathematicians normally refer to as
homomorphism.
AM calls this process Canonizing. Canonizing the two orders of Insert
(x into y, and y into x) would hopefully find the operation U=FLATTEN or
U=COUNT. Canonizing Same-length will cause the operation of Length to be synthesized.
Canonizing the notion of angles-equal-in-measure were the operations we normally
call rigid motions in the plane.

.COMMENT Numbers;

Let's pick the main thread of development again, before we lose it entirely.
Earlier, the operation "Same-length" was synthesized, as
a generalized form of the predicate which told when two structures were equal.
Same-length(x,y) is True iff x and y are two list structures which have
the same length (i.e., the same number of elements).
This new predicate was examined by AM, and sure enough it let many more
pairs of random objects return True than Equality did, yet it didn't let too
high a percentage through: just about 10%. This made AM want to find an
invariant, a canonizing function f, which put any given list structure x into
a standard form f(x), satisfying:

⊗6Same-length(x,y) iff Equal(f(x),f(y))⊗*

That is, x and y would have the same length precisely when the standard
forms of x and y were identically equal to each other.

AM had to synthesize this function f, step by step. First it performed
some experiments, and found that Same-length didn't care what the
type of its arguments were. If a certain Set S did/didn't satisfy
Same-length(R,S), then the same result would obtain if S were replaced
by Viewing S as a list, or as a bag, or as an oset. Thus the standard form
of a structure could be fixed as one specific type. But which should it
be (bag, set, list, oset)? To find out, AM ran two more experiments.
The first experiment was to see whether Same-length(R,S) was affected when
the order of elements inside R were changed. This turned out to be negative.
So R might as well be an unordered structure: bag or set.
The next experiment had AM decide whether or not multple elements inside
R would affect the value of Same-length(R,S). This turned out positive,
so multiple elements had to be taken into account. The canonical type
of argument was thus either bag or list. Together, the two experiments
indicated that the type had to be Bag. So the canonizing function f would
first convert any argument R to a bag.
A note tacked onto the Same-length concept's definition said that this
concept didn't look at the Car's or value-cells of its arguments.
That would mean that they should all be replaced by some fixed value, like T.
This checked out experimentally. So f should replace each element in the
structure R by the constant T. The final operation f synthesized was:

⊗6f(R) = Replace-each-element-by-T ( Convert-to--bag (R) )⊗*.

This operation would convert {a, (b,c,{d},e,e), q} into (T,T,T).
The set of standard forms for bags was called Canonical-bags, and renamed
by the user as Numbers. The canonizing operation f was called Length,
by the user, since it converts any structure into a "number" which represents
the length of that structure:

⊗6Same-length(R,S) iff Equal(Length(R),Length(S))⊗*

AM now made explicit an important analogy: bags↔numbers, equal↔same-length,
bag-operations↔[those same operations, restricted to canonical-bags].
Several minutes were spent developing these restricted bag-operations.
The old operation of inserting a bag S into itself provided a cute way to
"add 1" to
any number.
The Bag-union operation union turned into what we call Addition:

⊗6Bag-union( (T T T) (T T) ) = (T T T T T)⊗* means "3+2=5", in unary.

.ONCE TURN ON "{}"

TIMES was discovered in four ways, as discussed previously in the thesis.

The intersection of two "numbers" is the operation we call MINIMUM:

⊗6Intersect((T T T) (T T T T)) = (T T T)⊗* just says "Minimum(3,4)=3".

AM likes to find inverses, and the inverse of these operations turned out
to be the ones we call subtraction, factoring, division, less-than, etc.

AM likes coalescing, and some important operations were created that way, too:
Add(x,x) is Doubling; Times(x,x) is Squaring; the inverses of those were
Halving and Square-rooting (both restricted to natural numbers).

AM worried about which numbers could be halved or square-rooted,
and this led to the creation of the concepts Even-numbers and Perfect-squares.
When asking when a number z can be the result of a multiplication involving x,
AM derived the notion of Divides; analogously, AM defined the relation which
meant that Add of x and something else could yield z. That relation is just
"⊗6≤⊗*", and was called LEQ by the user. AM noticed many simple properties of
inequalities.

AM likes composing and reversing args,
and thereby figured out that most arithmetic operations
like Add and Times take a ⊗4bag⊗* of numbers to work on.

TIMES-1- was, as we said, factoring: given n, find all possible bags of numbers
(>1) whose product yielded n.
The identity of Times ("1") was intentionally excluded,
since its presence in any quantity would not affect the result of Times.
AM soon asked itself about numbers with extreme or unusual factorings.

.ONCE TURN ON "{}"

Primes were found in this way, as was Goldbach's conjecture. The example in
chapter {[2]EXAM1} went into this in great detail.
A large number of spurious analogous concepts were created and studied, to no
avail. For example, AM asked itself about numbers which could ⊗4uniquely⊗*
represented as the sum of two primes. As another example, AM defined the
concept of Square-roots-of-primes, which of course was not a winner.

The unique factorization of any number into primes was perceived quite
naturally, but many seemingly elementary concepts were left undiscovered.
AM never defined gcd (the greatest common divisors) onits own; it was,
however, possible to guide it to discovering that concept.

The task-by-task trace in the next section closes with the restriction of
addition to primes; i.e., p+q=r for primes p,q,r. This situation only occurs
when p (say) is 2, and q,r form a prime pair.
That trace will of course delve into concepts not mentioned above, and
conversely AM happended to miss, onthat run, some of those mentioned in this
section.
Finally, both sections omit mention of several interesting acitivites
AM performed: maximally-divisibles and all the geometric concepts, for example.
The line must be drawn somewhere. The frustrated reader should
try AM himself, and watch its progress.

.ASSEC(A `Nice' Task-by-task Trace)

. EXAM2: ASECNUM ;

.BEGIN BNN←0; TURN ON "{}";

.AT "CX" ⊂ " because many examples have recently been found, but not yet checked" ⊃

.AT "FD" ⊂ "Focus of Attention" ⊃

.AT "TX" ⊂ " is related to the very interesting concept TIMES" ⊃;

.AT "FX" ⊂ " because none exist yet" ⊃

Now that we've discussed this development at a fairly high level,
let's list what AM did task by task. The lines below give a highly
compressed "trace" of AM's sequence of behavior. The tasks in the
"best run"$$ Actually, a couple "very good" runs have been appended,
but NOT spliced together to the benefit of AM. $ are listed in
order, and numbered. For each, I have condensed AM's printout,
usually retaining some of the reasons AM had for atempting the task,
the methods AM used, the final outcome, and occasionally a bit of
commentary (in italics). The task numbers below correspond to the
numbering used in Section {[2]RESULT}.{[3]SHORTASK}, starting on page
{[3]SHORTASKP}.

.TRAT: PAGE;

.TRATS: SSECNUM;

:: Fill in examples of Compose: because Compose is highly-rated and
no examples of Compose are known yet. Several heuristics relevant,
but none succeeded. One of them, heuristic rule number {[3]RUNOP},
failed because no operations could be found which had examples. Also
important at this moment was heuristic rule number {[3]HAVEX}; see
Appendix {[2]ALLHEU}.

:: Fill in examples of Set-union: because Set-union is highly-rated,
and no examples of Set-union are known yet, and if some examples had
been known earlier then AM would have been able to Fill in examples
of Compose. Several heuristics relevant, but again none succeeded.

:: Fill in examples of Sets: because Sets is highly-rated, and no
examples of Sets are known yet, and if some examples had been known
earlier then AM would have been able to Fill in example of Set-union,
and AM was recently working on Domain(Set-union), and AM was recently
working on Range(Set-union). Several heuristic rules are relevant.
After rule {[3]INDEF} succeeded, so could many other techniques
(e.g., rule {[3]INVDEF}). In fact, it was so easy for AM to crank
out one example of a set after another, that rule {[3]SPEASY}
triggered.

:: Fill in specializations of Sets: because it was very easy to find
examples of Sets, and no specializations of Sets exist yet, and FD.
Many ways of creating new concepts, new specialized forms of Sets,
were relevant. AM created INT-Sets, defined as "λ (S) S is a set, and
all pairs of members of S satisfy the rare predicate P". AM also
created BI-Sets, defined as " λ (S) S=α{α}, or else both CAR(S) and
CDR(S) are BI-Sets." ⊗4The former specialization will lead to
Singletons, the latter deals with nests of braces (sets with no
atomic elements).⊗*$$ Recall that ⊗4italics⊗* signify the author's
comments, and contain information which AM -- and probably the user
as well -- could not have known at the time. $

:: Fill in examples of INT-Sets: because any such item will
automatically be an interesting example of a Set, and INT-Sets was
just created, and no examples of it are known yet. Very slowly, 6
examples were found via inference, and then 7 more were produced
quickly via more brutish methods. After eliminating duplicates, only
3 remain: α{α}, α{Aα}, and α{Bα}. In each case, the predicate P was
"Equal", and the worth of the concept Equal was raised slightly.

:: Check all examples of INT-Sets: because many unchecked examples
are present there, and FD. All three examples were confirmed. No
surprises were encountered. One of the three INT-Sets turned out to
be an Empty-structure, but no conjecture was actually formulated at
this time.

.RAISENIL←BNN;

:: Check all examples of Sets: because many were recently found and
never checked, and the previous task dealt with a specialization of
the Sets concept. One small modification had to be made to one of
the sets (namely, α{b,a,bα}→α{a,bα}). Based on empirical evidence,
AM hypothesizes that Sets may really be no more specialized than
Unordered-strucs. AM will reserve judgment until after it has tried
to find examples of Bags. (See heuristic rule {[3]RESERVE}, page
{[3]RESERVEP}.) Similarly, AM considers the possibility that all
Non-multiple-elements-strucs are really Sets as well. Before relying
on this flimsy conjecture, AM must first look for examples of Osets,
and see if ⊗4they⊗* are really also Sets.

:: Fill in examples of Bags: because no examples of Bags exist yet,
and to help settle the question about all unordered structures being
sets. 10 examples found. None are sets.

:: Fill in specializations of Bags: because it was very easy to find
examples of Bags, and no specializations of Bags are known about yet,
and FD. Many ways of creating new concepts, new specialized forms of
Bags, were relevant. AM created INT-Bags, defined as "λ (S) S is a
Bag, and all pairs of members of S satisfy the rare predicate P". AM
also created BI-Bags, defined as " λ (S) S=(), or else both CAR(S)
and CDR(S) are BI-Bags."

:: Fill in examples of Osets: because none exist yet, and to help
settle the question about all nonmult-strucs being sets. 13 distinct
examples found. None are sets.

:: Check examples of Osets: because many unchecked examples of Osets
exist on Osets.Exs, and FD. All confirmed. The prioirty rating of
this task is not high enough to inspire the creation of any new
concepts. One weak conjecture made: all ordered structures are Osets.
Will settle this by:

:: Fill in examples of Lists: because none exist yet, and to help
settle the question about all ord-strucs being osets. 29 examples
found. None are osets.

:: Check examples of Lists: because many unchecked examples of Lists
exist, and FD. All confirmed. Nothing special noted or motivated.

:: Fill in examples of All-but-first: because no such examples exist
yet, and AM was just working on Domain(All-but-first), and AM was
recently working on Domain(All-but-first). ⊗4The similarity of the
last two reasons escaped AM, and points up one of its flaws. AM is
swayed by the presence of a slightly-different reason just as much as
by a very-different supporting reason. There is no processing done on
the reasons.⊗* Choosing this task represents a radical shift of
attention for AM. 32 examples found, mostly by applying All-but-first
to the examples of Lists and Osets already known.

:: Fill in examples of All-but-last: because none exist yet, and AM
was recently working on Domain(All-but-last). Another
poorly-motivated task. ⊗4Luckily for AM, the user erroneously
believes that this task is also chosen to be symmetric with the last
task.⊗* 45 examples found.

.SELECT 1

:: Fill in specializations of All-but-last: because it's so easy to
find examples of it, and no specializations exist yet, and FD. The
syntactic methods AM can bring to bear are not enough to produce any
meaningful new concepts, and this task Fails. ⊗4Failure of a task
causes `FD' to go away for one cycle.⊗*

:: Fill in examples of List-union: because none exist yet. Another
wild shift of attention. 3 examples derived by symbolic manipulation
of the definition facet of this concept, then 22 more derived using
less inferential techniques (some were garnered by running
List-union.Alg itself on the early examples!).

:: Fill in examples of Proj1: FX. 26 found.

:: Check examples of All-but-first: because many were recently found
but not yet confirmed. All check out. This task has no repercussions
(new concepts, tasks, etc.).

:: Check examples of All-but-last: because many unchecked examples
exist on the Examples facet of All-but-last. All confirmed, with no
repercussions. ⊗4If the initial Worth values of All-but-first and
All-but-last are set high enough, AM defines a new concept at this
point, a new kind of ordered structure: λ (S) All-but-first(S) =
All-but-last(S). In fact, the only kind of Osets included herein are
those which are singletons or empty. Among lists, it also includes
those which contain just one kind of element.⊗*

:: Fill in examples of Proj2: because none exist yet. 26 found. AM
will typically quit looking for examples if (i) the time allocated
runs out, or (ii) the space allocated is used up, or (iii) 26
examples are found, or (iv) 151 attempts to find examples fail. ⊗4The
cosmic significance of 151 has rarely been recognized in print.
Perhaps 151 is more comic than cosmic. Seriously, these numbers must
be changed by almost an order of magnitude before any gross change in
AM's behavior is noticed.⊗*

:: Fill in examples of Empty-structures: FX, and the Worth of this
concept was increased recently (during task {RAISENIL}). Just by
looking at the examples of Structures (i.e., using heuristic rule
number {[3]LOOKGEX}), AM is able to get four empty ones: α{α}, [],
<>, (); i.e., the empty set, oset, list, and bag. Although some of
these are rederived in other ways, there are no other examples ever
found. This paucity triggers a rule which suggests this task:

:: Fill in generalizations of Empty-structures: because it was very
hard -- but not impossible -- to find examples of that concept, and
FD. AM examines the definitions of Empty-structure, but can't find
any recognizable syntactic pattern it knows about. It does find
⊗3(NOT (SOME-MEMBER S))⊗*, and tries to replace ⊗3SOME-MEMBER⊗* by a
specialization of same, but none is known to exist. ⊗4If the user
initially tells AM that First-member and Last-member are
specializations of Some-member, then AM ↓_can_↓ generalize
Empty-structures. In fact, it then comes up with what is equivalent
to `Empty-struc ∪ Unord-struc'. In the current setup, however, this
task fails. If AM had a better understanding of
constructive/destructive operations, it might have defined
Structures-with-empty-CARs, or perhaps Structures-with-empty-CDRs
(i.e., Singletons again).⊗*

:: Check examples of List-union: because many were recently added but
not yet confirmed. This shows the mechanical patience that a `stack'
gives you. Since no higher-priority task has been suggested, AM
attends to a task which has been on there for a while.

:: Check examples of Bags: because many examples and a couple
specializations exist. A few small modifications had to be made
(e.g., (A C B A) α→ (A A B C)).

:: Fill in examples of Bag-union: because none exist yet, and AM was
just working on Domain(Bag-union), and AM was just working on
Range(Bag-union). Note the influence of heuristic rule numer
{[3]FROB1}. This task proceeded smoothly, with 26 examples being
generated.

:: Check examples of Proj2: because several were recently found and
not yet checked. All confirmed, with no new suggestions generated.

:: Fill in examples of Set-union: because none exist yet. Again we
see rule {[3]FROB1} in action. 26 examples found.

:: Check examples of Set-union: CX, and FD (AM just worked on
Set-union). A few patches had to be made. Often, Set-union(x,y) was
equal to one of its arguments. AM therefore defined a new predicate
Eq-union(x,y) which is True iff Set-union(x,y)=x. The user later
renamed this "Superset-of", since this is the relationship of
containment. ⊗4In typical math texts, containment is introduced long
before union, and then this is a theorem: "A⊃B iff A∪B=A". But AM
used "∪" to form the ↓_definition_↓ of "⊃".⊗*

:: Fill in examples of Bag-insert: because none exist yet, and AM was
recently working on Domain(Bag-insert), and AM was recently working
on Range(Bag-insert). ⊗4A saddeningly stupid move for AM. It should
have rated Superset higher, and continued working on it.⊗* AM has no
trouble finding many examples of insertions into bags.

:: Check examples of Bag-insert: CX, and AM just worked on
Bag-insert. All examples were confirmed. This operation always
seemed to result in Nonempty bags. The Domain/range facet was so
amended. The value is never either of its arguments, but there is no
concrete action AM must take in such a situation, no compact way of
noting that anti-relationship (short of creating a full-blown
conjecture). Restricted to singletons, Bag-insert never produces a
singleton or an empty bag. AM defines the concept of a bag gotten by
doing a Bag-insert on a singleton; i.e., the notion of a doubleton
bag.

:: Fill in examples of Bag-intersect: FX, and AM was recently working
on Domain(Bag-intersect), and AM was recently working on
Range(Bag-intersect). 26 found without trouble.

:: Fill in examples of Set-insert: FX. Just another data-gathering
task, building up AM's store of empirical results.

:: Check examples of Set-insert: CX, and AM just worked on
Set-insert. Applying this operation always seems to result in
Nonempty sets. Domain/range so amended. The value is sometimes just
one of its arguments. AM defines what will eventually be called
Set-membership in this way: λ (x,S) Set-insert(x,S)=S. This is not
the only important result here. AM notices that Set-insert(x,S) is
always related to S by Superset-of. That is,
Superset-of(Set-insert(x,S), S) [for any x]. So conjectured. This
doesn't actually suggest anything marvelous for AM to do next,
however. Incidentally, during this task AM also defines the concept
of doubleton set.

:: Fill in examples of Bag-delete: FX. ⊗4Note that `working on bags'
is so long past that it is no longer given as a reason for this
task.⊗* Able to generate two examples by manipulating definitions
supplied with Bag-delete, then a couple dozen more were generated.
Some were generated by accessing already-known examples of the domain (i.e.,
the entries on the Examples facet of the
Bags concept) and then running Bag-delete.Alg on them.

:: Fill in examples of Bag-difference: FX. 26 found. ⊗4This is a
good vantage point to look back and ahead, and notice that while the
surrounding tasks are all reasonable data-gathering forays, the order
in which they're performed is unimportant. Later on, AM will follow
threads of discoveries, and the order of tasks then will appear very
important.⊗*

:: Check examples of Bag-intersect: CX. So many examples were found
that AM will entertain the idea of creating a specialized new
concept. Since the intersection of two randomly-chosen bags was
often empty, AM defined the concept of disjoint bags: λ (x,y)
Bag-intersect(x,y)=().

:: Fill in examples of Set-intersect: FX. Many found very easily.

:: Check examples of Set-intersect: CX,
and FD.
3 small modifications had to
be made. This time, AM noticed that the intersection of two sets was
often empty, and defined the Disjoint-sets concept. AM also noted
that x∩y was often one of those very same arguments, so it defined
the relation which is eventually renamed Subset: λ (x,y)
Set-intersect(x,y)=x. At the moment, AM didn't realize that there
was any connection between Subset and Superset. This tie came much,
much later (Task number {[3]SUBTIE} (qv.) in this run).

:: Fill in examples of List-intersect: FX, and the interest of
Intersect (the general concept of which this is a specialization) has
recently been increased a few times. 26 found without incident.

.ONCE PREFACE 1;

⊗6AM is bored⊗1$$ Of course "bored" is just what AM types out. It
reflects the low value of the top task on the agenda, and the meager
results obtained recently. Please forgive the anthropomorphism; it is
meant only to be "cute", not misleading. AM has no internal model
which could be called its "emotional state", as, e.g., PARRY [Colby 73]
claims. $⊗6! Will look at Suggest-type heuristics for new things to
do.⊗1

.ONCE PREFACE 1; INDENT 4,4,4;

⊗4If "Equality" is excised at this moment, AM continues the preceding
line of inquiry for a while, and then defines Singleton-osets, as
Osets all of whose members are equal to each other. AM notices that
All-but-first and All-but-last, restricted to Singleton-osets, always
yield the same result, namely the empty oset. AM then "generalizes"
this into the concept which is all the osets for which
All-but-first(x)=All-but-last(x). AM then turns to relationships
involving Subset and Superset, followed by a flurry of compositions
and coalescings, and their investigation. But Equality ↓_is_↓
present, so AM goes off on another course of exploration.⊗*

.ONCE PREFACE 1;

:: Fill in examples of Equal: because Equal has recently become more
interesting, and there are no examples known yet. Equal became more
interesting gradually, as INT-Sets were define and liked, Eq-union
defined and liked, etc. Once chosen, this task does not go smoothly.
By inference methods, only a couple examples were derived. Later,
when heuristic rule number {[3]RUNOP} was run, 151 failures were
encountered and only 2 successes. This is so small a success rate
that a heuristic rule strenuously proposed this next task, with a
high enough rating to be chosen right away:

:: Fill in generalizations of Equal: because Equal is apparently
quite rarely satisfied, and there are no entries yet on Equal.Genl.
Removing one of the two conjoined recursive calls in the recursive
definition given for Equal caused the creation of Equal-except-CARs
and Equal-except-CDRs. ⊗4The first predicate tests whether x and y
have the same number of elements; the second tests whether x and y
have the same number of leading left parens and the same first atom
after that final leading left parenthesis. As Knuth pointed out,
both of these concepts are valid ways of defining "numbers": one
counts the number of elements, the other counts the number of leading
left parentheses. But most structures which AM knows about are just
simple 1-level affairs. Therefore, Equal-except-CDRs was almost
always the same as "CAR(x)=CAR(y)". So AM never realized this
duality. If it had pushed BI-Sets and BI-Bags further, it might
have.⊗* Another concept created here is far more bizarre. Instead of
eliminating one of the two conjoined recursive calls, AM replaced the
AND with an OR. The new concept Genl-Eq3 was defined: `λ(x,y) if x or
y are non-lists, then EQ(x,y), else [Genl-Eq3(CAR(x),CAR(y)) ↓_OR_↓
Genl-Eq3(CDR(x),CDR(y)].' This is true if x and y have the same
length, or if the j↑t↑h element of each is the same (for any j), or
if the j↑th element of each has the same length (>0), or if the
i⊗Ath⊗* element of the j⊗Ath⊗* element of each is the same or has the
same length (for any i,j), or...

:: Fill in examples of Equal-except-CARs: because this is a new
generalization of Equal which must be examined, and because no
examples exist yet. Only 10 examples were found before the time
quantum was exhausted, but this was still many more than were found
for Equal before. The user now renamed this concept "Same-size".
⊗4A whirlwind of discovery is about to sweep the other two
generalizations of Equal out of the top spot on AM's agenda for quite
a while. If AM accidentally picked another of these to work on before
Same-size, only a small amount of time would have been spent before
moving on. For example, AM is unable to perform
Canonize.Algs(Genl-Eq3,Equal), so that would be a dead-end right
there.⊗*

:: Apply an Algorithm for Canonize to the args Same-size and Equal:
because a heuristic rule$$
The rule referred to is number {[3]DOCAN}, on page {[3]DOCANP}.
$ explicitly suggested that, and there are no
known examples of Canonize yet, and AM was just working on Same-size,
and AM was recently working on Equal, and Same-size was recently
created, and Same-size was just renamed by the user. AM performs
several experiments, and eventually synthesizes this canonizing
function: f(S) takes a structure S, converts it to a Bag, and
replaces each element by "T". This function is later renamed "Size"
by the user. AM also defines the set of canonical structures: bags
of T's. The user renames Bags-of-T's as "Numbers".

:: Restrict the Domain/range facet of Bag-union: because Bags-of-T's
(called Numbers now) is a new, interesting specialization of Bags,
and a heuristic rule explicitly suggested this, and FD, and many
examples of Bag-union exist. A new operation is defined,
Number-union, with domain/range entry <Number Number α→ Bag>. This
task used less than one cpu second.

:: Fill in examples of Number-union: because it is
recently-interesting, and it was just created, and AM was recently
working on Domain(Number-union). Several examples are found. ⊗4At
this point, the author turned on a tricky LISP printing function,
which converted each bag of T's to base-10 exponential notation
before allowing it to be typed out.⊗*

:: Check the domain/range of Number-union: because a heuristic rule
explicitly suggested that the range might really be "Number", and AM
was just working on Number-union, and AM was recently working on
Domain(Number-union) [i.e., working on `Numbers']. In fact, what the
heuristic rule suggested purely from symmetry desires turned out
empirically to be true: the value of Number-union(x,y) ⊗4did⊗* always
appear to be a Number (a bag of all T's). The result of this was to
amend the Domain/range facet of Number-union. Although AM regards
this uniformity as very interesting, it has no direct suggestion for
what to do next. The user renames this operation "Add2", since it
takes precisely 2 arguments (unary numbers) and adds them.

:: Restrict the domain/range of Bag-intersect: to Numbers, ⊗4for
similar reasons as above⊗*. After again noticing that the
intersection of 2 numbers always seems to be a number, this leads to
the operation which the user renames "Minimum". ⊗4Since the pattern
of tasks is Restrict → Fill in examples → Check examples, there is
not much point in listing all three tasks for all of these simple
restrictions. Each one will only get a single number in this listing.
Also, since the reasons for these restrictings are pretty much the
same, they won't be repeated for each task below.⊗*

.SELECT 1;

:: Restrict the domain/range of Bag-delete: to Numbers. The user
renames this operation "SUB1", although this is not quite accurate.
If x is not `T', then applying this operation to x and N (for some
number N represented as a bag of T's) will not alter N at all. AM
does not possess the reasoning abilities needed to anticipate this.

:: Restrict the domain/range of Bag-insert: to Numbers. The
domain/range entry is changed to <Anything Number α→ Bag>. Renamed
Number-insert. Although this new operation will in fact change a
number N, it may not necessarily change it into a number. The last
operation, SUB1, would always produce a number, though it might
sometimes fail to change N at all. Here is the sad discovery of that
asymmetry about Number-insert:

:: Check the domain/range of Number-insert: because a heuristic rule
explicitly suggested that the range might really be "Number". In
fact, its quickly seen ⊗4not⊗* to be. This operation is lowered in
worth, and never touched again. Due to AM's imperfect heuristics, the
worth of SUB1 is slightly higher still than this concept's.

:: Restrict the domain/range of Bag-difference: to Numbers. After
again noticing that the difference of 2 numbers always seems to be a
number, this leads to the operation which the user renames
"Subtract".

:: Fill in examples of Subtract: FX, and Subtract was just created.
Many examples are found. If a larger number is "subtracted" from a
smaller, the result is zero, according to this operation. Thus about
half of these examples have the value zero (empty bag). AM
explicitly defines the set of ordered pairs of numbers having zero
difference. It turns out that (in modern terminology) <x,y> is in
this new set iff x is less than or equal to y. So the user renames
this relation "LEQ".

:: Fill in examples of LEQ: FX, and LEQ was just created. 26 examples
found. When random numbers are chosen, the success rate is (as we
wise observors know) a little over 50%. This is very nice and AM's
estimate of the worth of LEQ rises.

:: Check examples of LEQ: CX, and the worth of LEQ has recently
risen. All confirmed. ⊗4Unfortunately, AM has derived Subset but not
Subbag, else it might have noticed that (for all numbers x and y,
represented as bags of T's) x⊗6≤⊗4y iff Subbag(x,y). Then AM could
simply observe that LEQ was just Subbag restricted to Numbers.
Looked at another way, AM has here discovered a restricted version of
the concept Subbag.⊗1

:: Apply algorithm of Coalesce to LEQ: because LEQ is an interesting
operation, recently created, many examples already exist for it, AM
just worked on LEQ, LEQ takes two of the same argument (Numbers), and
no examples of Coalesce are known yet. The new predicate is defined
as λ(x) x⊗6≤⊗*x. But this is Always-True, so AM conjectures that each
number is LEQ itself, and forgets the new coalesced version of LEQ.

:: Fill in examples of Parallel-join2: FX. Included is
Parallel-join2(Bags,Bags,Proj2) (initially called MJ2-BBP2), which
turns out to be multiplication of two numbers and is renamed "TIMES2"
by the user. Also included is
Parallel-join2(Structures,Structures,Proj1), which is a generalized
kind of Union operation (renamed "G-Union" by the user). Many losers
are also created, however, like
Parallel-join2(Bags,Sets,Set-difference)).

.Z7←BNN+12;

:: :- ⊗6{Z7}.⊗* Fill in and check examples of the operations just
createad. Nothing out of the ordinary is done here, just the routine
legwork of gathering empirical data for later use. No startling
conjectures made.

.BNN←Z7;

:: Fill in examples of Coalesce: FX. One shining example is
Self-compose, which takes any operation F (whose range is also a
domain component) and forms F-o-F. Another example is Self-Insert,
which takes a structure S and inserts S into S. Also created were:
Self-Delete, Self-Add, Self-Times, Self-Union, etc. A different kind
of coalescing was done for Parallel-replace2, Parallel-join2, and
Repeat2; the two structural arguments (the first and second arguments
for each) were merged, creating three new operations: Coa-repeat2,
Coa-join2, Coa-replace2. Coa-replace2, for example, takes a single
structure S and an operation F, and replaces each member x of S by
the value F(x,S).

:: Fill in examples of Self-Delete: FX, and Self-delete was just
created. Many examples are found quite easily, of course, except:

:: Check examples of Self-Delete: CX. Since trying to delete S from S
will never work, the value of Delete(S,S) is just S all the time.
Self-delete is the same as the identity operation. AM is able to
discover this and state it as a conjecture, obviating the need for
bothering with this concept ever again.

:: Fill in examples of Self-Member: FX, and Self-member was recently
created. Only negative instances are found.

:: Check examples of Self-Member: CX. This predicate is
Always-False, empirically. Replace by a conjec: Self-Member is the
same as the predicate Always-False; Member(S,S)=False for any S.
Also, an extra algorithm entry is added to Member.Alg: ⊗6Once Early
Quick: λ (x,y) if x=y then False.⊗* Also, a new task is proposed, to
generalize Self-Member. This never quite rises to the top of
theagenda, so it is never attempted.

:: Fill in examples of Self-Add: FX. Many found. User renames this
"Doubling", after he observes the many examples which are produced.

:: Check examples of Coalesce: CX. All were confirmed. Some were
already proving to be interesting, so the value of Coalesce was
raised.

:: Check examples of Add2: CX. All were confirmed. Somewhat
disappointingly, AM didn't notice anything special about Add2 at the
time.

:: Fill in examples of Self-Times: FX, and AM recently worked on
Isa(Self-Times) [namely, worked on Coalesce]. Renamed "Squaring" by
the user. 20 examples found before quitting due to lack of alotted
space.

:: Fill in examples of Self-Compose: FX. Created Add2-o-Add2 (two
versions: Add21 which is λ (x,y,z) (x+y)+z, and Add22 which is
x+(y+z)). Similarly, two versions of TIMES2-o-TIMES2, called TIMES21
and TIMES22. Also, two versions of Compose-o-Compose. Some losers
were defined as well, like Member(Member(x,y),z) and
Parallel-join2(S,R,Parallel-join2(P,Q,F)) -- the latter of which
accepts as arguments four kinds of structures and a function name.
Many minimally-acceptable concepts were created: Coalesce-o-Coalesce,
Squaring-o-Squaring, Doubling-o-Doubling, etc.

:: Fill in examples of Add21: FX, and Add21 was just created. This
operation is defined as λ (x,y,z) (x+y)+z. It is easy to find
examples.

:: Fill in examples of Add22: FX, and Add22 was recently created.
This operation is defined as λ (x,y,z) x+(y+z). It is easy to find
examples. Most of these examples are gotten from the "cousin"
concept Add21.

:: Check examples of Squaring: CX. All confirmed. ⊗4It is
unfortunate that this task intruded into AM's line of development.⊗*

:: Check examples of Add22: CX. During this process, AM notices that
Add21 and Add22 seem to be equivalent. Before conjecturing this,
though, AM will do this next task:

:: Check examples of Add21: CX, and this task was specifcally
suggested while AM was trying to check examples of Add21. After
checking these examples, Add21 and Add22 still appear equivalent. AM
conjectures this and merges the two operations. One consequence is
the boosting of the worth of the new, combined operation. The most
important aftereffect of this is that AM now knows that the "proper"
argument for a generalized kind of addition will be a Bag, not a
List, of numbers. This new kind of addition is called Add, to
distinguish it from Add2. Add2 takes a pair of numbers and adds
them, but Add accepts a ⊗4bag⊗* of numbers and forms their sum.

:: Apply algorithm for Invert to argument `Add': because Add is
interesting, recently worked on, and has never been inverted, and
there are no examples yet for Invert, and the worth of Add has
recently risen, and Add was just created. ⊗4By looking at those
reasons, we see why some semantic processing should be available.
There is tremendous overlap there, and the task is not really
supported by as many reasons as AM thinks.⊗* AM defines Inv-add(x)
(also called Add-1-) as the set of all bags of numbers (>0) whose sum
is x.

:: Fill in examples of TIMES21: FX. Defined as (x⊗8#⊗*y)⊗8#⊗*z. Many
are found.

:: Fill in examples of TIMES22: FX. Defined as x⊗8#⊗*(y⊗8#⊗*z). Many
are found.

:: Check examples of TIMES22: CX. As with Add, earlier, TIMES21 and
TIMES22 now appear equivalent. Before saying this, AM must do this
task:

:: Check examples of TIMES21: CX, and this task was specifically
suggested while AM was trying to check examples of TIMES22. After
checking these examples, TIMES21 and TIMES22 still appear equivalent.
AM conjectures this and merges the two operations. One consequence is
the boosting of the worth of the new, combined operation. The most
important aftereffect of this is that AM now knows that the "proper"
argument for a generalized kind of product will be a Bag, not a List,
of numbers. This new kind of multiplication is called TIMES, to
distinguish it from TIMES2. Notice the same property held true for
Add2, earlier. AM sets up an analogy between TIMES and ADD, because
of this common fact. ⊗4The analogy itself is close to what
mathematicians call the concept of Semigroups.⊗*

:: Apply algorithm for Invert to argument `TIMES': because TIMES
contains a new, promising analogy, and the analog of TIMES has been
inverted, and TIMES has never been inverted, and the worth of TIMES
has recently risen, and TIMES was just created. AM defines
Inv-TIMES(x) (also called TIMES-1-) as the set of all bags of numbers
(>1) whose product is x. AM noted that TIMES-1- should probably be
analogic to Add-1-.

:: Fill in examples of Parallel-replace2: FX. ⊗4I could kick AM for
doing this now!! The priority rating of this task happened to place
it above all the others, including those with extra bonusses because
of focus of attention. This task is merely diverting, not harmful in
any lasting sense, but it does degrade the apparent level of
purposefulenss of the system.⊗* Several examples of Parallel-replace2
are found. Included are Parallel-replace2(Bags,Bags,Proj2) (called
MR2-BBP2), and many losers. MR2-BBP2(S1,S2) replaces each element in
S1 by a full copy of the whole of S2. ⊗4This is the way that Skemp
suggests developing the notion of multiplication -- and in fact AM
will (in task {[3]DMULTT}) derives an operation which is equivalent
to TIMES2 just by unioning the results of this operation. In task
{[3]DMULT2} AM realizes that this is in fact just multiplication, and
merges those two operations, concurrently boosting the worth of that
combined concept greatly.⊗*

.Z7←BNN+16;

:: :- ⊗6{Z7}.⊗* Fill in and check examples of the operations just
created. ⊗4Nothing really worth our time (or AM's). Sigh.⊗*

.BNN←Z7;

:: Fill in examples of Compose: FX. It is very easy to create new
compositions -- most of them losers. Some of the concepts produced
(e.g., Size-o-Add-1-) were valuable but were lost amid the mass of
losers (e.g., Insert-o-Equal). Because of this flood of
poorly-motivated new concepts, a heuristic triggers which has AM
create a new specialization of Compose, called Int-Compose, by
conjoining onto Compose.Defn a few of the features from
Compose.Interest. The Worths of the new compositions just created
are all lowered, so that the (future) examples of Int-Compose will
predominate. ⊗4The task first considered in TASK 1 has finally
bubbled back up to the top of the agenda, and has proved to be quite
worthwhile.⊗*

.SELECT 1;

:: Fill in examples of Int-Compose: FX, and Int-Compose was just
created, and any example of Int-Compose is automatically an
interesting example of Compose, and the worth of Int-Compose is very
high. The two chosen operations G,H must be such that
ran(H)⊗6ε⊗*dom(G), and ran(G)⊗6ε⊗*dom(H); both G and H must be
interesting or at least newly-created. Well, two operations recently
dealt with are G-Union and MR2-BBP2. Since the range of MR2-BBP2 is
`Bags of Bags', it is ⊗4precisely⊗* equal to the domain of the
newly-synthesized operation G-Union. So one composition considered
is G-Union-o-MR2-BBP2. This is an alternate derivation of the
operation of multiplication. Also included are: TIMES-o-Squaring,
Coalesce-o-Compose, Insert-o-Delete, Delete-o-Insert, Add2-o-Times2,
etc. Although most of these operations were never investigated very
much, they are much better than the random compositions produced
during the previous task. This seems clear even to AM, even before
studying them very much.

.DMULTT: BNN;

.Z7←BNN+17;

:: :- ⊗6{Z7}.⊗* Fill in and check examples of the compositions just
createad. Nothing of great interest until...:

.BNN←Z7;

:: Check examples of G-Union-o-MR2-BBP2: ⊗1CX. AM discovers that
this operation is equivalent to MJ2-BBP2 (i.e., TIMES2). Since they
arose in very different ways, the worth of the new, merged concept
module is greatly increased, as is that of the more general operation
TIMES.

.DMULT2: BNN;

:: Fill in examples of Coa-repeat2: FX. 26 operations synthesized.
Foremost among them was Coa-repeat2(Bags-of-Numbers,Add2), which
turned out to be yet another derivation of multiplication! Also
produced was Coa-repeat2(Bags-of-Numbers,Times) -- a definition of
exponentiaion. Others included Coa-repeat2(Structures,Proj1), which
turns out to be the same as First-element-of, i.e., CAR, and
Coa-repeat2(Structures,Proj2), which turns out to be Last-element-of.

:: Check the examples of Coa-repeat2: CX, and FD. All confimed.

:: Apply algorithms for Invert to `Doubling': Doubling is
interesting, and it has never been inverted. The result is called
"Halving" by the user. AM decided to isolate the domain of Halving
(the range of Doubling). Such numbers are renamed by the user as
"Evens". ⊗4Although pleased with the result of this task, it was
somewhat jarring in the context of the preceding development.⊗*

:: Fill in examples of Self-Insert: FX. ⊗4AM has apparently lost the
"thread" of a development and is wandering around, taking care of
only moderately promising tasks.⊗* Many examples of this operation
are found.

.SELECT 1

:: Check examples of Self-Insert: CX, and FD. Nothing special found.
The result is never the same as the argument.

:: Fill in examples of Coa-repeat2-Add2: FX. Many found quickly, but at a
large cost in terms of storage space.

:: Check examples of Coa-repeat2-Add2: CX, and FD. Confirmed. AM noticed it's
the same as TIMES. Boost the worth of TIMES even higher, far above
that of any other concept. ⊗4AM will stay interested in TIMES for most
of the future of this run.⊗*

:: Apply algorithm for Invert to argument `Squaring': Squaring is
interesting, has never been inverted, TX, is related to the very
interesting concept Coalesce, is analogic to the already-inverted
concept Doubling. AM defines Inv-square(x) as the number$$ Actually:
the set of all numbers...$ whose square is x. Renamed by user as
"Square-root".

:: Fill in examples of Square-root: FX, and Square-root was just
created, and Square-root TX. AM spent quite a while on this task, and
only about 10 examples were found (discounting duplicates).

:: Fill in new algorithms for Square-root: because Square-root.Algs
are all too slow, and have been called on a great deal recently. ⊗4AM
has some zero↑t↑h order rules for improving algorithms, backed up by
a marvelous tactic: ask the user. In this case, AM asks the user for
a better algorithm, and he supplies one. Of course, the new
algorithm is completely opaque to AM. The user never tells AM how to
do something unless it had a (slow) way to do that thing already.⊗*
One fast new algorithm now exists.

:: Check examples of Square-root: CX, and FD. AM is plagued by the
frequency of numbers not having square-roots, so it isolates those
that do. It defined the set of numbers having a square-root, and this
concept was renamed "Perfect-squares" by the user.

:: Fill in examples of Coa-repeat2-Times: FX, and this concept TX.
⊗4A moderately rational thing to investigate.⊗* Examples are easily
found, but they take up a lot of space.

:: Check examples of Coa-repeat2-Times: CX, and FD. Nothing special
noticed, unfortunately (this is exponentiation, folks). ⊗4If the
user interrupts and tells AM that this is really interesting, AM soon
creates the specialization of it defined as Expon(x,2), and then AM
notices that this is just squaring. I.e., x↑2=x⊗*⊗8#⊗*⊗4x: the base
tie between exponentiation and multiplication. On its own, AM doesn't
rate Coa-repeat2-Times high enough to start this chain of
discoveries.⊗*

:: Fill in examples of Inv-TIMES: FX, and Inv-TIMES TX. Many found.

:: Fill in new algorithms for Inv-TIMES: because Inv-TIMES.Algs are
all too slow, and have been called on a great deal recently, and
TIMES-1- TX, and FD. AM asks the user, who supplies a decent
recursive algorithm for this function.

:: Check examples of Inv-TIMES: CX, and FD. This proceeds along, and
all are confirmed. A heuristic rule notices that the domain/range is
<Number → Sets-of-Bags-of-Numbers>; it searchs for an operation whose
Domain/range facet contains an entry (compatible with)
<Sets-of-Bags-of-Numbers → Number>, and fails; next it looks for an
operation whose dom/range is <Sets-of-Bags → Set or Bag>, and finds
that G-Union fills the bill. Therefore, the rule suggests the
following task (with a high rating):

:: Apply Compose algorithm to G-Union and Inv-TIMES: because the
three concepts involved are interesting, related to TIMES, and this
task was specifically suggested by the preceding one. The
composition is created, as specified in the task. This new operation
has domain/range <Number → Set-of-Numbers>, and is thus given a
higher rating than either of its constituents. It is renamed
"Divisors" by the user.

:: Fill in examples of Divisors: FX, and Divisors TX, and divisors
was just created. Many examples are found, but only after much
inefficient searching amid the set of all (known examples of)
numbers.

:: Fill in new algorithms for Divisors: because Divisors.Algs are all
too slow, and have been called on a great deal recently. AM asks the
user, who supplies a decent iterative algorithm for this function.

:: Fill in examples of Perfect-squares: FX, and Perfect-squares TX.
15 found, after which the space allocation was exhausted.

:: Fill in specializations of TIMES: because TIMES is very
interesting, has very few known specializations, and it was very easy
to find examples of TIMES. AM now allocates a huge chunk of cpu time
and space to this task. A few specializations of TIMES are gotten by
plugging in a distinguished value for one argument:
Times1(x)⊗6≡⊗*1⊗8#⊗*x, Times0(x)⊗6≡⊗*0⊗8#⊗*x, etc. Other new
operations are simply TIMES with its domain restricted to a bag of
special numbers: Times-sq has its domain a bag of perfect squares,
Times-ev takes only even arguments, etc. Others (inefficient to
compute) are TIMES with its range restricted: Times-to-evens requires
that the result be even, Times-to-sq for square results, etc.

:: Check examples of Divisors: CX, and Divisors TX. Often,
Divisors(x) is interesting (to AM) as a set; AM isolates the cases by
defining 0-Div, 1-Div, 2-Div, and 3-Div, the sets of numbers whose
Divisors value is the empty set, a singleton, a doubleton, and a
tripleton, respectively. AM will gradually partition the examples of
Divisors into these categories, as AM tries to fill in examples of
each kind of number.

.SELECT 1; ONCE INDENT 4,4,3; PREFACE 1;

⊗4This is the point where the example in Chapter {[2]EXAM1} begins,
and is also roughly the point where the unadulterated LISP trace
(Appendix {[2]TRACES}.{[3]UNADULT}) ends. Both this section and the
earlier condensed task-by-task trace, found in Chapter {[3]RESULT},
go further.⊗*

:: Fill in examples of 1-Div: FX, and 1-Div was just created, and TX.
Only one example found: "1". This causes the Worth of 1-Div to be
lowered.

:: Fill in examples of 0-Div: FX, and 0-Div was recently created, and
TX. None found. Lower the worth of this concept.

:: Fill in examples of 2-Div: FX, and this concept TX. About 19 are
found (out of about 170 attempts). This is a nice ratio, a nice
density within the natural numbers -- not too many nor too few to be
interesting. As a result, 2-Div.Worth is slightly raised.

:: Check examples of 2-Div: CX, and the worth of 2-div has just
increased, and FD. The existing examples were confirmed, but no
pattern noticed. ⊗4This was heart-stopping, since 2-Div is the notion
of prime numbers; here AM is tossing it off as
non-interest-catching!⊗*

:: Fill in examples of 3-Div: FX, and 3-Div TX. As with 2-Div, a nice
number of examples were found (albeit on the scarce side of nice).

:: Check examples of 3-Div: CX, and 3-Div TX., and FD. All
confirmed. All are perfect squares! Very unexpected (both by AM and
the user). AM greatly increased the worth of 3-Div. One suggestion,
due to the fact that 3-Div was now In-dom-of Square-root, was:

:: Restrict Square-root to numbers which are in 3-Div: Square-root is
interesting, 3-Div is very interesting, and the preceding task
specifically requested this action. AM calls the new concept Root3.

:: Fill in examples of Root3: FX, and Root3 was just created, and
Root3 is related to the very interesting concept 3-Div. Many
examples found. In fact, it was easy to take the square-root of each
known example of 3-Div.

:: Check examples of Root3: CX. All confirmed. Each result turned
out to be a 2-Div type of number. Very surprising. Conjecture: the
square-root of a number with 3 divisors is a number with 2 divisors.
AM raised the worths of all the concepts involved. At this point,
the user renamed 2-Divs as "Primes".

:: Restrict Squaring to Primes: Squaring is interesting, Primes is
recently interesting, and the preceding task specifically suggested
this action. AM calls the result Square2.

:: Fill in examples of Square2: FX, and Square2 was just created.
Many found.

:: Check the domain/range facet of Square2: it has been specifically
suggested that the range of Square2 may be 3-Div, and 3-Div is very
interesting, and Square2 is related to the interesting concept
Primes, and FD. As hoped for, all are 3-Divs. Conjecture: x is a
Primes iff its square is a 3-Div iff it is the square-root of a
3-Div.

:: Restrict Squaring to 3-Divs: Squaring is interesting, 3-Div is
interesting, and an earlier task specifically suggested this action.
The result is called Square3. ⊗4AM's past few successful tasks have
now incremented the Worths of certain activities above their true
value: AM will now be tied up with restricting Squaring and
Square-rooting to all the concepts involved. The net effect will be
to lower those inflated worth ratings, and to lower the user's -- and
the reader's -- opinion of AM.⊗*

.SELECT 1;

:: Restrict Square-rooting to Primes: Square-root is interesting,
Primes is interesting, and an earlier task specifically requestd this
action. Call the result Root2.

:: Fill in examples of Square3: FX, and Square3 is related to the
interesting concept 3-Div, and Square3 was recently created. Only 9
examples found before running out of space. By analogy, since
Divisors-of-o-Square2 was interesting, AM considers:

:: Compose Divisors-of and Square3: Analogic to tripletons, and
Divisors-of is interesting, and Square3 is interesting, and the
preceding task specifically suggested this action. AM calls the
result Div-Sq3.

:: Fill in examples of Div-Sq3: FX, and Div-Sq3 was just created. 9
examples found right away, by simply running Divisors-of.Algs on the
9 known examples of Square3.

:: Check examples of Div-Sq3: CX. All such examples are Same-size.
Although AM doesn't have the notion of `5-ness' explicitly, they each
have 5 members. A specialized hack heuristic observes the general
pattern: Divisors-o-Primes are all of the same size;
Divisors-o-Squaring-o-Primes are all of the same size;
Divisors-o-Squaring-o-Squaring-o-Primes are all of the same size; A
new conjecture is formulated and typed to the user:
Divisors-o-Repeat(Squaring)-o-Primes will all be the same size.

.ONCE SELECT 4; PREFACE 0; INDENT 4,4,3;

This expresses the fact that, for a given n, p↑[⊗72n⊗*] has the same
number of divisors for each prime p. AM was not able to figure out
that number of divisors (it is 2n+1). This would be a trivial
sequence extrapolation problem, but AM of course had no heuristics
for dealing with numbers, hence no sequence extrapolation techniques.
Deriving the concept of sequence extrapolation itself would have been
quite astounding, but never occurred. Discovering the concept of
inductive inference and studying it explicitly in isolation is quite
a sophisticated achievement -- that's what AI researchers spend much
of their time trying to accomplish. This is one time when AM was
much further from discovering a theorem than it appeared to the
casual observor.

.Z7←BNN+8;

:: :- ⊗6{Z7}.⊗* More confirmations and explorations of the above
conjecture. Gradually, all its ramifications lead to dead-ends (as
far as AM is concerned).

.BNN←Z7;

:: Fill in examples of Root2: FX, and Root2 is related to the
interesting concept Primes. But no examples at all are found. This
is not surprising, since very few primes are also perfect squares.
AM conjectures that there are none. Worth of Root2 is lowered.

:: Check examples of Inv-TIMES: CX. This is a break in the previous
smooth line of development. Inv-TIMES appears to always contain a
singleton bag; in fact, Inv-TIMES(x) always contains the singleton
bag (x). Another conjecture AM makes: Inv-TIMES(x) always contains a
bag of primes. This last hypothesis suggests the following two tasks:

:: Restrict the range of Inv-TIMES to bags of primes: because
Inv-TIMES is interesting, is related to the very interesting concept
TIMES, primes are more interesting than numbers at the moment, FD,
and the previous task specifically suggested this action. AM calls
the new result Prime-Times.

:: Restrict the range of Inv-TIMES to singletons: because Inv-TIMES
is interesting, is related to the very interesting concept TIMES,
singletons are more interesting than sets at the moment, a recent
task specifically suggested this action, and FD. AM calls the new
result Single-Times.

:: Fill in examples of Prime-times: FX, and Prime-times was recently
defined, and Prime-times is related to the interesting concept
Primes, and Prime-times is related to the interesting concept TIMES.
Many examples are found.

:: Check examples of Prime-times: CX, and FD, and Prime-times TX.
The value of Prime-times(x) is always a singleton set. Conjecture:
Inv-TIMES(x) contains precisely one bag of primes. User renames this
conjecture "The unique factorization theorem". AM prints out that
this will probably be very natural and important. The reason for
this is that Primes was itself derived from TIMES, so any conjecture
connecting them is quite natural. Any ⊗4unexpected⊗* such natural
conjecture will probably be useful.

:: Fill in examples of Single-TIMES: FX, and this concept TX. Many
found.

:: Check examples of Single-TIMES: CX, and it TX, and FD. The value
of Single-times(x) is always a singleton set. Conjecture:
Inv-TIMES(x) contains precisely one singleton bag. Single-TIMES is
actually the same as Bag-insert, in the sense that both
Single-TIMES(x) and Bag-insert(x) give the value (x) -- the bag
containing only x. In the latter case, this is because Bag-insert is
"smart" enough to supply an empty bag as the second argument S to
Bag-insert(x,S), if S is missing.

:: Fill in examples of Self-set-union: FX. ⊗4AM has dropped the
momentum of its previous whirlwind of discovery, and is simply
marking time, gathering evidence.⊗* Many examples are found.

:: Check examples of Self-set-union: CX, and FD. Apparently, this
concept is the same as Identity (but with domain/range restricted to
Sets). Replace by a conjecture.

:: Fill in examples of Self-bag-union: FX. ⊗4On the same track, but
boring.⊗* Many found.

:: Check examples of Self-bag-union: CX, and FD. All are confirmed.
Nothing interesting noticed.

:: Fill in examples of Inv-ADD: FX. Slowly, examples were found.

:: Check examples of Inv-ADD: CX, and FD. Inv-ADD(x) always contains a
singleton bag (x), a doubleton bag, a tripleton, a bag of 1's,... So
many conjectures that:

:: Restrict the domain of Inv-ADD: because Inv-Add is interesting,
related to the interesting concept Add, FD, and the previous task
specifically suggested this action. When the domain is restricted to
primes, AM defines `Inv-Add-primes'. When it restricts Inv-Add to
work only on evens, AM thereby defines the operation it calls
`Inv-Add-evens'.

:: Fill in examples of Inv-add-primes: FX, and this concept was just
defined, and FD. Many found.

:: Check examples of Inv-add-primes: CX, and FD. All were confirmed,
but nothing special noticed.

:: Fill in examples of Inv-add-evens: FX, and this concept was
recently defined. Many examples found.

:: Check examples of Inv-add-evens: CX, and FD. Confirmed.
Inv-Add-evens(x) always contains a bag of primes. This is mildly
surprising, and prompts:

:: Restrict the range of Inv-Add-evens to bags of primes: because
Inv-Add-evens is recently interesting, and Primes is more interesting
than Numbers, and the previous task specifically requested this
action (hence FD). AM names the new operation Prime-ADD.

:: Restrict the range of Inv-ADD to singletons: because Inv-Add is
interesting, singletons are more interesting than sets, AM just
worked on Inv-Add, AM recently worked on Inv-Add, and an earlier task
specifically suggested this action. Thus Single-Add is born.

:: Fill in examples of Prime-ADD: FX, and Prime-add was recently
defined. Many found.

:: Check examples of Prime-ADD: CX, and FD. The value of Prime-ADD(x)
is always a nonempty set (of bags of primes). So conjectured
(domain/range changed). User renames this conjecture "Goldbach's
conjecture".

:: Fill in examples of Single-ADD: FX, and this concept was recently
defined. Many found.

:: Check examples of Single-ADD: CX, and FD. The value of
Single-ADD(x) is always a singleton set. Conjecture: Inv-ADD(x)
contains precisely one singleton bag. Single-ADD is actually the same
as Bag-insert (and Single-TIMES).

:: Restrict the range of Prime-ADD to singletons: because analogic to
Prime-TIMES, and Prime-Add is interesting, and Singletons is more
interesting than Sets. This was initiated by analogy, not by an
earlier task specifically suggesting that the restriction be done.
In this case, AM is asking which numbers are uniquely representable
as the sum of two primes. The new operation is Prime-ADD-s.

:: Fill in examples of Prime-ADD-s: FX, and Prime-ADD-s was just
defined. Many examples are found, but after a nontrivial processing
effort.

:: Check examples of Prime-ADD-s: CX, and FD. Nothing special
noticed.

:: Fill in examples of Times-sq: FX. ⊗4Losing the thread of
discovery, moving back to data-gathering blindness.⊗* Recall that
Times-sq is just TIMES restricted to operate on perfect squares. Many
examples found.

:: Check domain/range of Times-sq: because the range of this
operation may actually be Perfect-squares, and examples of Times-sq
were just filled in, and this concept TX, and FD. The range really
does seem to be as hoped for. Conjecture: the product of perfect
squares is a perfect square.

:: Fill in examples of Times1: FX. Recall that
Times1(x)⊗6≡⊗*TIMES(1,x). Many found.

:: Check examples of Times1: CX, and FD. Apparently Times1 is just a
restriction of Identity. Times1 is therefore replaced by a lone
conjecture: Times(x,1)=x.

:: Check examples of Times-sq: CX. Confirmed.

:: Fill in examples of Times0: FX, and Times0 TX. Many found.

:: Fill in examples of Times2': FX, and this operation TX. Many
found. Recall that Times2(x) is defined as 2⊗8#⊗*x.

:: Check examples of Times2': CX, and FD. Apparently, Times2' is the
same as Doubling. That is, x+x=2⊗8#⊗*x. A very powerful tie between
Add and Times! This was highly unexpected. It is not predicted by
the existing analogy. By analogy, AM now defines Ad2(x) as x+2, and
will invesitigate that.

:: Fill in examples of Ad2: FX, and Ad2 was jsst created. Many
examples found.

:: Check examples of Ad2: CX, and FD. Nothing interesting noticed.
⊗4AM didn't have the notion of Add1-o-Add1 at that moment, or it
could have derived the analogic conjecture between successor/addition
that it found between addition/multiplication. The same lack of
knowledge about exponentiation inhibited the perception the
times/exponent analogic relationship. Every little bit of knowledg
about operations involving Add served to raise the worth of Add
slightly. Finally, the following task rises to the top:⊗*

.SELECT 1;

:: Fill in specializations of Add: because there are very many
examples of Add, and Add has recently risen in interest. Among those
created are: Add0 (x+0), Add1, Add3, Add-sq (addition restricted to
perfect squares), Add-ev (sum of even numbers), Add-pr (sum of
primes), etc. The techniques used were the same ones used to
specialize TIMES earlier.

:: Check examples of Times0: CX. The value always seems to be 0. So
conjectured. Times0 goes away.

:: Fill in examples of Times-ev: FX. Recall that Times-ev is just
like TIMES restricted to operating on even numbers. Many examples
found.

:: Check examples of Times-ev: CX, and FD. Apparently all the
results are all Evens. Conjecture: the product of even numbers is
even. ⊗4Note that no explicit task of the form "Check D/R" had to be
executed in order to notice and correct this. The net result here is
the same: a conjecture and an alteration of the Domain/range facet of
Times-ev.⊗*

:: Fill in examples of Times-to-ev: FX. That is, consider bags of
numbers which multiply to give an even number. Many found.

:: Fill in examples of Times-to-sq: FX. Find bags of numbers whose
product is a perfect square. A few found right away, then great
difficulty in locating more examples.

.SELECT 1; ONCE TURN ON "↑↓_";

:: Check examples of Times-to-sq: CX, and FD. All arguments always
seem to be squares. Conjec: Times-to-sq is really the same as
Times-sq. Merge the two. ⊗4This is a false conjecture, since, e.g.,
the product of the numbers in the bag (2 2 3 3) is a perfect square,
but ↓_none_↓ of those numbers is itself a square. This did AM no
harm, and AM never detected its mistake.⊗*

:: Check examples of Times-to-ev: CX. The domain always seems to
contain an even number. So conjectured. ⊗4I.e., if the product of
some numbers is even, then so is one of those numbers. This
conjecture is true, at least.⊗*

:: Fill in examples of Self-Union: FX. ⊗4Reaching way back in time.
Ugh.⊗* Many found.

:: Check examples of Self-Union: CX, and FD. Nothing special noticed.

:: Fill in examples of SubSet: FX. Many found.

:: Check example of SubSet: CX, and FD. Nothing special noticed.

:: Fill in examples of SuperSet: FX. Many found.

.ONCE TURN ON "{}";

:: Check examples of SuperSet.: CX, and FD. AM notices that if <x,y>
are related by SubSet, then Reverse-ord-pair(<x,y>) are related by
SuperSet, and conversely. This is the base connection between union
and intersection (see Tasks {[3]SUBBAG} and {[3]SUPERBAG}, where
these two concepts are defined). That is, x⊂y iff y⊃x.

.COMMENT SUBTIE: BNN;

:: Fill in examples of Compose-o-Compose-1: ⊗1FX. AM creates some
poor combinations (e.g., Square-o-Count-o-ADD-1-), some explosive
ones (e.g.,
(Compose-o-Compose)-o-(Compose-o-Compose)-o-(Compose-o-Compose)), and
even a few -- very few -- winners (e.g., SUB1-o-Count-o-Self-Insert).
⊗4This is too much like throwing "flying, hooked atoms" up into the
air, and hoping that three of them collide fortuitously. While a
little guidance may help you to find good collisions of 2 such
fliers, the combinatorial explosion swamps the poor researcher when
he takes them on three at a time. As St. Augustine observed, the Latin
`cogito' derives from `shake together', but `intelligo' derives from
`select among'. ⊗*

:: Check examples of Compose-o-Compose-1:⊗1 CX, and FD. Nothing
interesting to find.

:: Fill in examples of Compose-o-Compose-2:⊗1 FX. Recall that the
difference between this operation and the last one is merely in the
order of the composing: F-o-(G-o-H) versus (F-o-G)-o-H. AM recreates
many of the previous tasks' operations.

.ONCE TURN OFF "-";

:: Check examples of Compose-o-Compose-2:⊗1 CX, and FD. Nothing
noticed yet. ⊗4Later on, AM finds that one after another of the
operations created in the preceding task as, say,
Compose-o-Compose-1(F,G,H), is really the same as the corresponding
operation created as Compose-o-Compose-2(F,G,H). Eventually, AM
conjectures that those two Compose-o-Compose operations are really
the same; that is, Compose is associative.⊗*

.Z7←BNN+21;

.SELECT 1;

:: :- ⊗6{Z7}.⊗* Fill in and check examples of the losing compositions
just created.

.BNN←Z7;

:: Fill in examples of Add-sq: FX, and Add-sq is related to the
interesting concept Add. Recall that Add-sq is just addition,
restricted to perfect squares. Many examples found.

:: Check domain/range entries of Add-sq: because the range may also
be Perfect-squares, and examples of Add-sq were just filled in (hence
FD), and Add-sq is related to the interesting concept Add. The range
isn't Perfect-squares (e.g., 4+9 is not square), but some values are,
so AM defines the predicate Add-sq-sq(x,y), which is True iff x and y
are perfect squares and their sum is a perfect square as well (e.g.,
Add-sq-sq(16,9)). Add-sq-sq.Defn is a predicate which is true if its
3 arguments are squares, say x↑2, y↑2, z↑2, and if the sum of the
first two is equal to the third: x↑2+y↑2=z↑2.

:: Fill in examples of Add-pr: FX, and Add-pr is related to the
interesting concept Add. That is, the sum of a pair of primes.

:: Check Domain/range entries of Add-pr: CX. AM defines the set of
pairs of primes whose sum is also a prime (e.g., Add-pr-pr(2,5)).
⊗4In a rather bizarre way, AM has defined prime pairs. The sum of two
primes can be a prime iff one of them is 2. So Add-pr-pr can really
be considered a predicate on one prime argument x, which returns True
iff x+2 is a prime; i.e., iff x is the lower member of a prime pair.
There is something at once awful and sublime about this derivation of
prime pairs. Perhaps this captures the spirit of AM's actions as a
whole, so let's stop this trace right here.⊗*

.ASSEC(An `Unadulterated' Trace)

.UNADULT: SSECNUM;

Here is the way that the AM program begins. The human user's typing
will appear in italics$$ This is not a doctoring: I have written an
i/o routine for AM which prints α%4 before everything the user types,
and α%* afterwards. The `PUB' documentation program interprets this to mean
"switch to font 4" and "switch back to font 1". This document was
PUBBed with font 4 defined as italics. $. He first types ⊗4(START)⊗*
to start the system, after which AM asks him some questions. Finally,
the main Select&Execute-a-TASK loop of AM is entered.

.ONCE TURN ON "{}"

The careful reader will notice several small changes in this
transcript, compared to the nicely doctored ones which preceded it.
For one thing, the
task numbering here is not precisely the same as in the rest of this
document. A task is called a "Cand", and the agenda is called
"CANDS". Only some of the reasons are printed out, and they are not
as "chatty" as the reasons in. e.g., Chapter {[2]EXAM1}'s example
trace. The user has asked AM to type out the top three tasks on the
agenda at each "cycle". In a better hardware environment, the user
could dynamically watch the top hundred tasks bubbling around on one
side of a CRT screen. To interrupt AM, the user types CONTROL-I.
At that moment he has a very limited syntax of
questions he may ask. See (αα) below (page {[3]ALPP}).

An approximate level of familiarity of the user with the AM program
is maintained by AM, as a numeric variable. Initially, its value is
determined by the number of times the human user has used AM in the
past.$$ I shall resist the temptation to call this a simple "user
model", even in a footnote. $ It gradually changes in value as a
single session proceeds. Many print statements use this variable to
determine the necessary level of detail to type. For example,
contrast
the line pointed to by an arrow labelled
⊗2(β)⊗* below with the line labelled
⊗2(ε)⊗*. In between, the variable increased to
the point where a detailed message was thought to be superfluous.
The level of detail needed for clarity should not be confused with
the level of verbosity of output that is desired. Should the user see
every function call, or the results of each task, or just monitor the
overall character of what AM is doing? A separate variable is
maintained for this verbosity indication. Finally, another partially
independent dimension is the amount of control the user wishes to
have on AM. Must he approve each move AM makes, occasionally redirect
AM, be able to ask questions? Another variable indicates the level of
user control in effect at the moment. The first several questions
deal with setting up these parameters.

.BEGIN NOFILL INDENT 0 SELECT 3; PREFACE 0; TURN OFF "{}→←"

INTERLISP-10 4-JAN-75 ...

Good afternoon, Doug.

←⊗4(START)⊗*

Please type in your last name ( then carriage-return):⊗4FEIGENBAUM⊗*

Almost ready to enter AM's main loop, Ed.

Ed, you have used AM once before.
Do you feel like you need some refreshing about how to work with it? ⊗4Yes⊗*

AM has 113 concepts to start with, each with only
about 5 of its potential 30 facets ( parts) filled in.
Repeatedly, AM selects a part of a concept,
and tries to fill it in or check it. In this process, new
concepts may emerge and be granted full status; in those cases,
almost all their parts will be empty at the time of their creation.

CANDS is a list of suggested future activities for AM.
Repeatedly, AM picks a Candidate from CANDS and does what it says.
A typical Cand might be:
( Fill in examples of interesting compositions).
Each Cand also has a list of reasons explaining why it was
proposed, and a numeric rating of its overall value.

DO-THRESHhold is a numeric variable that indicates the lowest
rating a Cand may have and still be executed by AM.
If no Cand on CANDS measures up, then all the concepts try to suggest
new candidates, which are merged into CANDS.

DISCLAIMER: The user interface is still unfinished, and in fact
the only polished part is the following message describing it! Try it
at your own risk!

You, Ed, can affect this concept growing process.
At any time, you may hit α↑I, which will Interrupt me.
Once interrupted, I will answer one question or perform one task;
a typical question I can answer is WHY;
a typical task is ( Raise the Interest Level of the Frobnate Concept).
A second way to interact with me is to help me decide
which Cand to do next each time. You can see my top choices, their
reasons, and overrule me if you want. The variable Seencands is
the number of Candidates you see each time, and Ucontrol indicates
the amount of control you have over my choosing.

To keep you informed, I will periodically print out messages.
The level of verbosity can be changed by interrupting me.

More details can be obtained when you interrupt with α↑I.

Verbosity Level (1 - 10, or ?) .... ( Please terminate your response
with a carriage-return) ...⊗4?⊗*

Verbosity = the amount of data that AM spews out to Ed.
In this system, Verbosity is just a numeric-valued variable
which the Printing functions look at.
Verbosity level 0 suppresses all messages.
Verbosity level 5 lets most important messages get printed.
Verbosity level 10 dumps out enough to actually get some
feeling for the inner workings of AM.

The suggested value for Ed is 8.

Verbosity Level (1 - 10, or ?) .... ( Please terminate your response
with a carriage-return) ...⊗410⊗*

User-control Level ( 0 - 10, or ? ) ....⊗4?⊗*

User-control = the degree to which you supervise AM's activities
In this system, User-control is just a numeric-valued variable
which the top-level control functions look at.
User-control level 0 lets you gain control only via α↑I.
User-control level 5 lets you see a few of AM's alternatives,
and waits 6 seconds for you to OK its choice.
User-control level 10 displays several alternative Candidates,
and waits indefinitely until you to select one.

User-control Level ( 0 - 10, or ? ) ....⊗44⊗*

Before deciding which new Cand to work on, I'll print my top choices.

How many Candidates would you like to see each time?
( I suggest 4): ⊗43⊗*

Should I tell you my reasons for each Cand I am considering selecting
each time? ⊗4No⊗*

Should I tell you my reasons for the Cand I actually select each time?
⊗4Yes⊗*

If you have not typed anything within 4 seconds after a prompt,
then AM will fill in a default answer for you.
A space will suffice to keep AM from defaulting on you,
while you think about what to reply to any question AM asks you.
In general, your response should be terminated by a carriage return.

Would you like to reset this waiting time? ⊗4No⊗*

Entering AM's main loop now.

No Cand on CANDS is good enuf.
Do-thresh reduced from 500 to 333
Must find new candidates and merge them into CANDS.

The top 3 Cands are:
1: Fill in some examples of Set-struc-intersect
2: Fill in some examples of Set-struc-join
3: Fill in some examples of Coalesce

I choose first Cand. OK? ⊗4yes.⊗*

The reason for considering this Cand is: (We have no examples
for SET-STRUC-INTERSECT yet)

Beginning 1st cycle.

Failed. Tried to fill in new examples of SET-STRUC-INTERSECT.

⊗6<At this moment, the user hit control-I and interrupted AM.>⊗*
.ALPP: PAGE; ONCE TURN ON "→";
?: (W, I, E, M, N, ?, Q) ⊗4?⊗* →⊗8←αααα⊗*⊗2(αα)⊗3

Here are more detailed explanations of your options:
W Why: AM gives Ed the explanation behind its last printed
message.
I Interest: Ed can modify the interest ratings of concepts and
Candidates.
E Evaluate: Ed types in an expression and AM runs EVAL on it.
M Message: What was the last message that AM did NOT type out
because the verbosity was too low?
N Name: Rename some concept to whatever you want to call it.
Q Quit: resume execution.

In general, AM will automatically resume execution after answering one
query. You must hit α↑I again to interrupt.

?: ⊗4W⊗*
Why: (No examples of SET-STRUC-INTERSECT were found; there
is no reason to even consider specializing it further)

This Cand used 11.159 cpu seconds.

The top 3 Cands are:
1: Fill in some examples of Set-struc
2: Fill in some examples of Coalesce
3: Fill in some examples of Nonempty-struc

I choose first Cand. OK? ⊗4yes.⊗*

The 2 reasons for considering this Cand are:
(Active-exs specifically asked for some examples of SET-STRUC
, while trying to Fill in some Set-struc-intersect examples)
(We have no examples for SET-STRUC yet)

Beginning 2nd cycle.

Creating new Being, similar to SET-STRUC, named INT-SET-STRUC, but
restricted so as to make it more interesting.
An INT-SET-STRUC is any SET-STRUC for which (Each pair of
elements satisfies the same interesting predicate P (for some P)).

Filled in examples of SET-STRUC.
0 examples existed originally on SET-STRUC.
11 potential new entries were just proposed.

Eliminating duplicates, the newly constructed examples are:
(CLASS)
(CLASS DOUG CORDELL BRUCE)
(CLASS R0-7 R1-7 R2-7 R3-7 R4-7 R5-7 R6-7 R7-7)
(CLASS A)
(CLASS B)
(CLASS A B)
(CLASS 0 D F I M)
After eliminating duplicate and already-known entries, AM finds that.
only 7 new, distinct examples of SET-STRUC had to be added.

Do-thresh raised from 332 to 346 because this last Cand succeeded, so
.ONCE TURN ON "→"
we raise our hopes-- and our standards-- temporarily.→⊗8←αααα⊗*⊗2(β)⊗3

This Cand used 23.743 cpu seconds.

The top 3 Cands are:
1: Fill in some examples of Int-set-struc
2: Fill in some examples of Coalesce
3: Check all examples of Set-struc

I choose first Cand. OK? ⊗4yes.⊗*

The reason for considering this Cand is: (Any example of
INT-SET-STRUC is automatically an interesting example of SET-STRUC)

Beginning 3rd cycle.

Won't try to create a restricted interesting version of INT-SET-STRUC.

Filled in examples of INT-SET-STRUC.
0 examples existed originally on INT-SET-STRUC.
13 potential new entries were just proposed.

Eliminating duplicates, the newly constructed examples are:
(CLASS)
(CLASS A)
(CLASS B)
After eliminating duplicate and already-known entries, AM finds that.
only 3 new, distinct examples of INT-SET-STRUC had to be added.

.ONCE TURN ON "→"
Do-thresh raised from 346 to 358.→⊗8←αααα⊗*⊗2(ε)⊗3

This Cand used 11.881 cpu seconds.

The top 3 Cands are:
1: Fill in some examples of Obj-equal
2: Check all examples of Int-set-struc
3: Check all examples of Set-struc

I choose first Cand. OK? ⊗4yes.⊗*

The reason for considering this Cand is: (We have no examples
for OBJ-EQUAL yet)

Beginning 4th cycle.

Record of attempts to find examples:-----------------------------------
An ex ( sought) is: ((CLASS A),(CLASS A) → T) +------------------
----+---------------------------------------+---------------------------
--------+----------+------+---

Found 6 examples ( and 151 non-exs), in 11.644 secs.
Ratio of exs to non-exs is too low ( 6 / 151); Exs are too sparse.
AM will sometime try to generalize OBJ-EQUAL.
Won't try to create a restricted interesting version of OBJ-EQUAL.

Filled in examples of OBJ-EQUAL.
0 examples existed originally on OBJ-EQUAL.
6 potential new entries were just proposed.

Eliminating duplicates, the newly constructed examples are:
((CLASS A) (CLASS A) → T)
((CLASS O D F I M) (CLASS O D F I M) → T)
(FALSE FALSE → T)
After eliminating duplicate and already-known entries, AM finds that.
only 3 new, distinct examples of OBJ-EQUAL had to be added.

Do-thresh raised from 358 to 359.

This Cand used 17.886 cpu seconds.

No Cand on CANDS is good enuf.
Do-thresh reduced from 359 to 239
Must find new candidates and merge them into CANDS.

The top 3 Cands are:
1: Fill in some examples of Set-struc-intersect
2: Check all examples of Int-set-struc
3: Fill in some generalizations of Obj-equal

I choose first Cand. OK? ⊗4yes.⊗*

The reason for considering this Cand is: (We have no examples
for SET-STRUC-INTERSECT yet)

AM recently tried this same Cand, so let's skip it now.

The top 3 Cands are:
1: Check all examples of Int-set-struc
2: Fill in some generalizations of Obj-equal
3: Check all examples of Set-struc

I choose first Cand. OK? ⊗4yes.⊗*

The reason for considering this Cand is: (Some new , unchecked
examples of INT-SET-STRUC have recently been added)

Beginning 5th cycle.

AM is forgetting the entire SUGG facet of the INT-SET-STRUC concept.
Because: (No sense using this suggestion more than once).

Checked examples of INT-SET-STRUC and all entries were confirmed

This Cand used 11.362 cpu seconds.

The top 3 Cands are:
1: Check all examples of Set-struc
2: Fill in some generalizations of Obj-equal
3: Fill in some examples of Coalesce

I choose first Cand. OK? ⊗4yes.⊗*

The reason for considering this Cand is: (Some new , unchecked
examples of SET-STRUC have recently been added)

Beginning 6th cycle.

Based on empirical experiments, AM believes that SET-STRUC may really
be no more specialized than UNORD-OBJ.

Closer inspection reveals that the evidence for this was quite flimsy.
AM will wait until some examples of any of these have been found: (
BAG-STRUC), and then see if they truly also are SET-STRUC's.

Based on empirical experiments, AM believes that SET-STRUC may really
be no more specialized than NONMULT-STRUC.

Closer inspection reveals that the evidence for this was quite flimsy.
AM will wait until some examples of any of these have been found: (
OSET-STRUC), and then see if they truly also are SET-STRUC's.

Checked examples of SET-STRUC.
5 entries were there initially.
1 small modifications had to be made.
5 entries are present now.

This Cand used 8.008 cpu seconds.

The top 3 Cands are:
1: Fill in some examples of Bag-struc
2: Fill in some examples of Oset-struc
3: Fill in some generalizations of Obj-equal

I choose first Cand. OK? ⊗4yes.⊗*

The reason for considering this Cand is: (We have no examples
for BAG-STRUC yet)

Beginning 7th cycle.

Filled in examples of BAG-STRUC.
0 examples existed originally on BAG-STRUC.
19 potential new entries were just proposed.

Eliminating duplicates, the newly constructed examples are:
(BAG)
(BAG A)
(BAG B)
(BAG A B)
(BAG A A)
(BAG A A B)
(BAG 0 D F I M)
(BAG A B (BAG B) (CLASS))
(BAG BRUCE CORDELL DOUG)
(BAG R0-7 R1-7 R2-7 R3-7 R4-7 R5-7 R6-7 R7-7)
After eliminating duplicate and already-known entries, AM finds that.
only 10 new, distinct examples of BAG-STRUC had to be added.

XEQ-CAND

Do-thresh raised from 239 to 264.

This Cand used 17.692 cpu seconds.

The top 3 Cands are:
1: Fill in some generalizations of Obj-equal
2: Fill in some examples of Oset-struc
3: Fill in some examples of Coalesce

I choose first Cand. OK? ⊗4yes.⊗*

The reason is: (The ratio of examples to non-examples of
OBJ-EQUAL is too low ; OBJ-EQUAL is too specialized , too narrow)

Beginning 8th cycle.

Considering genlizing a recursive defn of OBJ-EQUAL
Will try to remove a conjunct.
2 possible conjuncts to choose from.
AM generalizes OBJ-EQUAL into the new concept GENL-OBJ-EQUAL, by
not recursing on the CAR of each arg.
i.e., GENL-OBJ-EQUAL will not have a recursive check
like this one, which is present in OBJ-EQUAL:

APPLYB
(QUOTE OBJ-EQUAL)
(QUOTE DEFN)
(CAR BA1)
(CAR BA2)
AM generalizes OBJ-EQUAL into the new concept GENL-OBJ-EQUAL-1,
by not recursing on the CDR of each arg.
i.e., GENL-OBJ-EQUAL-1 will not have a recursive check
like this one, which is present in OBJ-EQUAL:

APPLYB
(QUOTE OBJ-EQUAL)
(QUOTE DEFN)
(CDR BA1)
(CDR BA2)

If any of (GENL-OBJ-EQUAL GENL-OBJ-EQUAL-1) ever seems to be too
specialized, AM will consider disjoining it with other members of that
set.

Filled in generalizations of OBJ-EQUAL.
0 generalizations existed originally on OBJ-EQUAL.
2 potential new entries were just proposed.

Eliminating duplicates, the newly constructed generalizations are:
GENL-OBJ-EQUAL
GENL-OBJ-EQUAL-1
After eliminating duplicate and already-known entries, AM finds that.
all 2 new, distinct generalizations of OBJ-EQUAL had to be added.

Do-thresh raised from 264 to 335.

This Cand used 6.667 cpu seconds.

The top 3 Cands are:
1: Fill in some examples of Genl-obj-equal-1
2: Fill in some examples of Genl-obj-equal
3: Fill in some examplls of Oset-struc

I choose first Cand. OK? ⊗4yes.⊗*

The reason is: (The generalization GENL-OBJ-EQUAL-1 of OBJ-EQUAL
is relatively new and has no exs of its own yet , excepting those
of OBJ-EQUAL)

Beginning 9th cycle.

?: ⊗4N⊗*

Rename which existing concept? ⊗4GENL-OBJ-EQUAL⊗*

What is its new name? ⊗4SAME-SIZE⊗*

Done.

Record of attempts to find examples:
-
An ex ( sought) is: ((VECTOR BAG) (VECTOR B (BAG B) (CLASS) A))+-----++
-+---+-------++-+--++-+------------++-------+--+--------+-----------+-+-
---------++--+--------------------++------+-+----+

Found 26 examples ( and 105 non-exs), in 8.037 secs.
A nice ratio of exs/non-exs was encountered for GENL-OBJ-EQUAL-1
Won't try to create a restricted interesting version of
GENL-OBJ-EQUAL-1.

Filled in examples of GENL-OBJ-EQUAL-1.
0 examples existed originally on GENL-OBJ-EQUAL-1.
26 potential new entries were just proposed.

Eliminating duplicates, the newly constructed examples are:
((VECTOR BAG) (VECTOR B (BAG B) (CLASS) A) → T)
((OSET 0 D F I M) (OSET 0 D F I M) → T)
((BAG) (BAG DON ED) → T)
((OSET D M I F 0) (OSET D M I F 0) → T)
((PAIR DOUG BRUCE) (PAIR DOUG BRUCE) → T)
((VECTOR BAG) (VECTOR D M I F 0) → T)
((VECTOR B) (VECTOR D M I F 0) → T)
((BAG B) (BAG B) → T)
((VECTOR D M I F 0) (VECTOR A A B) → T)
((BAG A) (BAG A B) → T)
((VECTOR) (VECTOR B (BAG B) (CLASS) A) → T)
((OSET BRUCE DON) (OSET B A) → T)
((PAIR COMPOSE-EXS COMPOSE-EXS) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) → T)
((OSET R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6) (OSET 0 D F I M) → T)
((OSET A B (BAG B) (CLASS)) (OSET B (BAG B) (CLASS) A) → T)
((OSET 0 D F I M) (OSET B) → T)
((VECTOR A A) (VECTOR A B) → T)
((OSET DON ED) (OSET BAG) → T)
((BAG A A B) (BAG) → T)
((OSET B) (OSET BRUCE DON) → T)
((CLASS DON ED) (CLASS A) → T)
((PAIR LIST-STRUC-INSERT CANONIZE) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) → T)
((VECTOR) (VECTOR BAG) → T)
((OSET A) (OSET D M I F 0) → T)
((VECTOR BAG) (VECTOR BAG) → T)
After eliminating duplicate and already-known entries, AM finds that.
only 25 new, distinct examples of GENL-OBJ-EQUAL-1 had to be added.

Do-thresh raised from 335 to 367.

This Cand used 29.095 cpu seconds.

The top 3 Cands are:
1: Fill in some examples of Same-size
2: Check all examples of Genl-obj-equal-1
3: Fill in some examples of Coalesce

I choose first Cand. OK? ⊗4yes.⊗*

The 2 reasons are:
(Interestingness of SAME-SIZE has changed recently)
(The generalization SAME-SIZE of OBJ-EQUAL is relatively new
and has no exs of its own yet , excepting those of OBJ-EQUAL)

Beginning 10th cycle.

Record of attempts to find examples:
-
An ex ( sought) is: ((VECTOR A) (OSET B))+---+--+--------+----++++-----
----+-+---+-+-----+-------+--+-+---+-+----------+-+----------+---+-----+
----+---+---------------+

Found 26 examples ( and 102 non-exs), in 8.032 secs.
A nice ratio of exs/non-exs was encountered for SAME-SIZE
Won't try to create a restricted interesting version of SAME-SIZE.

Filled in examples of SAME-SIZE.
0 examples existed originally on SAME-SIZE.
36 potential new entries were just proposed.

Eliminating duplicates, the newly constructed examples are:
((OSET 0 D F I M) (OSET 0 D F I M) → T)
((OSET D M I F 0) (OSET D M I F 0) → T)
((PAIR DOUG BRUCE) (PAIR DOUG BRUCE) → T)
((BAG B) (BAG B) → T)
((OSET BRUCE DON) (OSET B A) → T)
((PAIR COMPOSE-EXS COMPOSE-EXS) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) → T)
((OSET A B (BAG B) (CLASS)) (OSET B (BAG B) (CLASS) A) → T)
((VECTOR A A) (VECTOR A B) → T)
((PAIR LIST-STRUC-INSERT CANONIZE) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) → T)
((VECTOR BAG) (VECTOR BAG) → T)
((VECTOR A) (OSET B) → T)
((BAG A B) (OSET B A) → T)
((CLASS 0 D F I M) (BAG 0 D F I M) → T)
((VECTOR B) (BAG A) → T)
((PAIR LIST-STRUC-INTERSECT ANYB-SPEC) (PAIR DOUG BRUCE) → T)
((OSET DON ED) (PAIR LIST-STRUC-INTERSECT ANYB-SPEC) → T)
((BAG 0 D F I M) (VECTOR D M I F 0) → T)
((VECTOR B) (BAG B) → T)
((OSET BAG) (OSET A) → T)
((VECTOR A A) (BAG A A) → T)
((CLASS A) (VECTOR BAG) → T)
((CLASS A B) (OSET A B) → T)
((PAIR COMPOSE-EXS COMPOSE-EXS) (OSET DON ED) → T)
((VECTOR A) (OSET A) → T)
((OSET BAG) (CLASS A) → T)
((OSET A) (CLASS A) → T)
((OSET B) (OSET A) → T)
((BAG 0 D F I M) (OSET 0 D F I M) → T)
((OSET DON ED) (OSET ED CORDELL) → T)
((OSET ED CORDELL) (OSET B A) → T)
((OSET A) (BAG B) → T)
((OSET B A) (OSET A B) → T)
((VECTOR B A) (OSET ED CORDELL) → T)
((OSET A) (VECTOR BAG) → T)
((OSET B A) (OSET DON ED) → T)
After eliminating duplicate and already-known entries, AM finds that.
only 35 new, distinct examples of SAME-SIZE had to be added.

Do-thresh raised from 367 to 406.

This Cand used 21.725 cpu seconds.

The top 3 Cands are:
1: Check all examples of Same-size
2: Check all examples of Genl-obj-equal-1
3: Check all things which just barely miss being examples of
Same-size

I choose first Cand. OK? ⊗4yes.⊗*

The reason is: (Some new , unchecked examples of SAME-SIZE
have recently been added)

Beginning 11st cycle.

Checked examples of SAME-SIZE.
35 entries were there initially.
1 had to be completely discarded.
4 had to be transferred elsewhere.
30 entries are present now.

Do-thresh raised from 406 to 421.

This Cand used 6.917 cpu seconds.

The top 3 Cands are:
1: Check all examples of Genl-obj-equal-1
2: Check all things which just barely miss being examples of
Same-size
3: Fill in some examples of Coalesce

I choose first Cand. OK? ⊗4yes.⊗*

The reason is: (Some new , unchecked examples of
GENL-OBJ-EQUAL-1 have recently been added)

Beginning 12nd cycle.

Checked examples of GENL-OBJ-EQUAL-1.
25 entries were there initially.
1 had to be completely discarded.
4 had to be transferred elsewhere.
20 entries are present now.

This Cand used 4.711 cpu seconds.

No Cand on CANDS is good enuf.
Do-thresh reduced from 421 to 333
Must find new candidates and merge them into CANDS.

The top 3 Cands are:
1: Canonize these 2 arguments: Genl-obj-equal-1 and Obj-equal
2: Canonize these 2 arguments: Same-size and Obj-equal
3: Fill in some examples of Coalesce

I choose first Cand. OK? ⊗4yes.⊗*

The reason is: (It would be nice to find a canonical ( with
respect to Genl-obj-equal-1 and Obj-equal ) representation C for any
Object X ; that is ,
( GENL-OBJ-EQUAL-1 x y ) iff
( OBJ-EQUAL ( C x ) ( C y ) ) .
)

Beginning 13rd cycle.

Experiments indicate that GENL-OBJ-EQUAL-1 is affected by the varying
the type of structure of its arguments.

GENL-OBJ-EQUAL-1 doesn't look at any elements of OBJECT except possibly
the car of the structure which denotes its type, so AM replaces the
tail of OBJECT by a canonical distinguished tail, say NIL.

Succeeded!

Some conjectures that AM considers believable:

OBJ-EQUAL, restricted to canonical OBJECT's, is indistinguishable
from GENL-OBJ-EQUAL-1.

There is a powerful analogy between

GENL-OBJ-EQUAL-1.................OBJ-EQUAL
OBJECT...........................CANONICAL-OBJECT
operators on and into those operators restricted to
OBJECT...........................CANONICAL-OBJECT
statements involving these.......statements involving these

Do-thresh raised from 333 to 341.

This Cand used 9.02 cpu seconds.

The top 3 Cands are:
1: Fill in some examples of Canonical-object
2: Restrict the following: Genl-obj-equal-1 Canonical-object Domain

3: Canonize these 2 arguments: Same-size and Obj-equal

I choose first Cand. OK? ⊗4yes.⊗*

The reason is: (Any example of CANONICAL-OBJECT is a canonical
example of OBJECT)

Beginning 14th cycle.

AM will now try to produce examples of CANONICAL-OBJECT by running the
following operations:
(CANONIZE-GENL-OBJ-EQUAL-1&OBJ-EQUAL).

Won't try to create a restricted interesting version of
CANONICAL-OBJECT.

Filled in examples of CANONICAL-OBJECT.
0 examples existed originally on CANONICAL-OBJECT.
165 potential new entries were just proposed.

Eliminating duplicates, the newly constructed examples are:
(VECTOR)
(BAG)
(CLASS)
(OSET)
FALSE
T
TRUE
(PAIR)
(T)
(NIL)
(TRUE)
(FALSE)
After eliminating duplicate and already-known entries, AM finds that.
only 12 new, distinct examples of CANONICAL-OBJECT had to be added.

Do-thresh raised from 341 to 391.

This Cand used 23.827 cpu seconds.

The top 3 Cands are:
1: Restrict the following: Genl-obj-equal-1 Canonical-object Domain

2: Canonize these 2 arguments: Same-size and Obj-equal
3: Fill in examples of Coalesce

I choose first Cand. OK? ⊗4yes.⊗*

The reason is: (GENL-OBJ-EQUAL-1 was one of the predicates
which defined the new concept CANONICAL-OBJECT , so it is worth
considering the restriction of GENL-OBJ-EQUAL-1 to that subset of
OBJECT 's)

Beginning 15th cycle.

Succeeded!

Do-thresh raised from 391 to 431.

This Cand used 3.562 cpu seconds.

The top 3 Cands are:
1: Canonize these 2 arguments: Same-size and Obj-equal
2: Fill in some examples of Coalesce
3: Restrict the following: Obj-equal Canonical-object Domain

I choose first Cand. OK? ⊗4yes.⊗*

The reason is: (It would be nice to find a canonical ( with
respect to Same-size and Obj-equal ) representation C for any Object
X ; that is ,
( SAME-SIZE x y ) iff
( OBJ-EQUAL ( C x ) ( C y ) ) .
)

Beginning 16th cycle.

Experiments indicate that SAME-SIZE is not affected by varying the type
of structure of its arguments.

Experiments indicate that SAME-SIZE is not affected by reordering
elements of its structural arguments.
So any canonical arguments can be Bags and Sets.

Experiments indicate that SAME-SIZE is affected by the presence of
multiple elements in its structural arguments.
So any canonical arguments can be Bags and Lists.

SAME-SIZE doesn't look at the specific elements in OBJECT, like
OBJ-EQUAL does, so AM can replace them all by a single distinguished
element, say T.

Succeeded!

Some conjectures that AM considers believable:

OBJ-EQUAL, restricted to canonical BAG-STRUC's, is indistinguishable
from SAME-SIZE.

There is a powerful analogy between

SAME-SIZE........................OBJ-EQUAL
BAG-STRUC........................CANONICAL-BAG-STRUC
operators on and into............those operators restricted to
BAG-STRUC.................. CANONICAL-BAG-STRUC
statements involving these.......statements involving these

Do-thresh raised from 431 to 457.

This Cand used 17.297 cpu seconds.

The top 3 Cands are:
1: Fill in some examples of Canonical-bag-struc
2: Restrict the following: Same-size Canonical-bag-struc Domain
3: Restrict the following: Bag-struc-join Canonical-bag-struc Domain

I choose first Cand. OK? ⊗4yes⊗*.

The reason is: (Any example of CANONICAL-BAG-STRUC is a canonical
example of BAG-STRUC)

Beginning 17th cycle.

AM will now try to produce examples of CANONICAL-BAG-STRUC by running
the following operations:
(CANONIZE-SAME-SIZE&OBJ-EQUAL).

Filled in examples of CANONICAL-BAG-STRUC.
0 examples existed originally on CANONICAL-BAG-STRUC.
211 potential new entries were just proposed.

Eliminating duplicates, the newly constructed examples are:
(BAG)
(BAG T T)
(BAG T T T)
(BAG T)
(BAG T T T T T)
(BAG T T T T)
(BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T)
After eliminating duplicate and already-known entries, AM finds that.
only 7 new, distinct examples of CANONICAL-BAG-STRUC had to be added.

Do-thresh raised from 457 to 478.

This Cand used 35.918 cpu seconds.

The top 3 Cands are:
1: Restrict the following: Same-size Canonical-bag-struc Domain
2: Restrict the following: Bag-struc-join Canonical-bag-struc Domain
3: Restrict the following: Obj-equal Canonical-object Domain

I choose first Cand. OK? ⊗4yes⊗*.

The reason is: (SAME-SIZE was one of the predicates which defined
the new concept CANONICAL-BAG-STRUC , so it is worth considering
the restriction of SAME-SIZE to that subset of BAG-STRUC 's)

Beginning 18th cycle.

Succeeded!

Do-thresh raised from 478 to 495.

This Cand used 3.311 cpu seconds.

?: ⊗4N⊗*

Rename which existing concept? ⊗4CANONICAL-BAG-STRUC⊗*

What is its new name? ⊗4NUMBER⊗*

Done.

?: (W, I, E, M, N, ?, Q) ⊗4N⊗*

Rename which existing concept? ⊗4CANONIZE-SAME-SIZE&OBJ-EQUAL⊗*

What is its new name? ⊗4SIZE⊗*

Done.

The top 3 Cands are:
1: Check all examples of Number
2: Restrict the following: Obj-equal Canonical-object Domain
3: Check all examples of Canonical-object

I choose first Cand. OK? ⊗4yes⊗*.

The 2 reasons are:
(Interestingness of NUMBER has changed recently)
(Some new , unchecked examples of NUMBER have recently been
added)

Beginning 19th cycle.

Checked examples of NUMBER and all entries were confirmed

This Cand used 1.909 cpu seconds.

The top 3 Cands are:
1: Check all examples of Canonical-object
2: Check all things which just barely miss being examples of Number
3: Restrict the following: Bag-struc-join Number Domain

I choose first Cand. OK? ⊗4yes⊗*.

The reason is: (Some new , unchecked examples of
CANONICAL-OBJECT have recently been added)

Beginning 20th cycle.

CANONICAL-OBJECT has 7 examples which occupy 11 list cells, but is not
interesting enough to warrant taking up that much space; so about 2
will be selected at random and forgotten.
Checked examples of CANONICAL-OBJECT.
12 entries were there initially.
10 were never confirmed or rejected.
2 had to be completely discarded.
5 entries are present now.

This Cand used 16. 626 cpu seconds.

No Cand on CANDS is good enuf.
Do-thresh reduced from 495 to 340
Must find new candidates and merge them into CANDS.

The top 3 Cands are:
1: Fill in some examples of Size
2: Fill in some examples of Coalesce
3: Restrict the following: Bag-struc-join Number Domain

I choose first Cand. OK? ⊗4yes⊗*.

The reason is: (We have no examples for SIZE yet)

Beginning 21st cycle.

Record of attempts to find examples:
An ex ( sought) is: (BAG T T)++++++++++++++++++++++++++

Found 26 examples ( and 0 non-exs), in .996 secs.
A nice ratio of exs/non-exs was encountered for SIZE
Won't try to create a restricted interesting version of SIZE.

Filled in examples of SIZE.
13 examples existed originally on SIZE.
26 potential new entries were just proposed.

Eliminating duplicates, the newly constructed examples are:
((BAG T T) → (BAG T T))
((BAG T T T T T) → (BAG T T T T T))
((BAG B) → (BAG T))
((BAG A A) → (BAG T T))
((BAG T T T) → (BAG T T T))
((BAG T T T T) → (BAG T T T T))
((BAG A B) → (BAG T T))
((BAG R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6) → (BAG T T T T T T T T T T T T T T T T T T
T T T T T T T T T T T T))
((BAG A A B) → (BAG T T T))
((BAG 0 D F I M) → (BAG T T T T T))
((BAG A) → (BAG T))
((BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T T) → (BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T T))
((BAG DON ED) → (BAG T T))
((BAG A B (BAG B) → (CLASS)) (BAG T T T T))
((BAG A B) → (BAG T T))
After eliminating duplicate and already-known entries, AM finds that.
only 14 new, distinct examples of SIZE had to be added.

Do-thresh raised from 340 to 414.

This Cand used 9.2 cpu seconds.